1use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14 CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
15 issue::{CreateIssueArgs, EditIssueArgs, IssueData, IssueProvider, ListIssueArgs},
16 types::{CommentData, Label, State, UserSummary},
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22 GITLAB_MAX_PER_PAGE,
23 commit::encode_project_path,
24 error::parse_glab_error,
25 runner::{CommandRunner, RealCommandRunner},
26};
27
28#[derive(Debug, Clone)]
44pub struct GitLabIssueProvider<R: CommandRunner = RealCommandRunner> {
45 repo: String,
50 repo_target: String,
57 runner: R,
59}
60
61impl GitLabIssueProvider<RealCommandRunner> {
62 #[must_use]
66 pub fn new(repo: impl Into<String>) -> Self {
67 let repo = repo.into();
68 Self {
69 repo_target: repo.clone(),
70 repo,
71 runner: RealCommandRunner,
72 }
73 }
74
75 #[must_use]
79 pub fn with_session(session: &gitflow_core::Session) -> Self {
80 let repo = session.repo.clone();
81 Self {
82 repo_target: repo.clone(),
83 repo,
84 runner: RealCommandRunner,
85 }
86 }
87
88 #[must_use]
94 pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
95 Self {
96 repo: repo.into(),
97 repo_target: remote_url.into(),
98 runner: RealCommandRunner,
99 }
100 }
101}
102
103impl<R: CommandRunner> GitLabIssueProvider<R> {
104 #[must_use]
109 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
110 let repo = repo.into();
111 Self {
112 repo_target: repo.clone(),
113 repo,
114 runner,
115 }
116 }
117
118 #[must_use]
123 pub fn with_runner_and_repo_target(
124 repo: impl Into<String>,
125 repo_target: impl Into<String>,
126 runner: R,
127 ) -> Self {
128 Self {
129 repo: repo.into(),
130 repo_target: repo_target.into(),
131 runner,
132 }
133 }
134
135 async fn ensure_label_exists(&self, name: &str) -> Result<()> {
143 debug!(repo = %self.repo, name, "auto-creating missing label via `glab label create`");
144
145 let output = self
146 .runner
147 .run(
148 "glab",
149 &[
150 "label",
151 "create",
152 "--name",
153 name,
154 "--color",
155 "ededed",
156 "--repo",
157 &self.repo_target,
158 ],
159 )
160 .await
161 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label create: {e}")))?;
162
163 if !output.status.success() {
164 let glab_err = parse_glab_error(&output.stderr);
165 tracing::debug!(error = %glab_err, "Failed to auto-create label");
166 return Err(CoreError::Platform(format!(
167 "Failed to auto-create label '{name}': {}",
168 glab_err.user_message
169 )));
170 }
171
172 Ok(())
173 }
174}
175
176#[derive(Debug, Clone, Deserialize)]
180struct ApiUser {
181 username: String,
182 #[serde(default)]
183 id: u64,
184}
185
186impl From<&ApiUser> for UserSummary {
187 fn from(u: &ApiUser) -> Self {
188 Self {
189 login: u.username.clone(),
190 id: u.id.to_string(),
191 }
192 }
193}
194
195#[derive(Debug, Clone, Deserialize)]
201struct MilestoneRefApi {
202 #[serde(default)]
203 id: u64,
204 #[serde(default)]
205 iid: Option<u64>,
206 title: String,
207}
208
209impl From<MilestoneRefApi> for gitflow_core::types::MilestoneRef {
210 fn from(api: MilestoneRefApi) -> Self {
211 Self {
212 number: api.iid.unwrap_or(api.id),
213 title: api.title,
214 }
215 }
216}
217
218#[derive(Debug, Clone, Deserialize)]
220struct IssueApiResponse {
221 iid: u64,
222 title: String,
223 #[serde(default)]
224 description: Option<String>,
225 state: String,
226 #[serde(default)]
227 labels: Vec<String>,
228 #[serde(default)]
229 author: Option<ApiUser>,
230 #[serde(default)]
231 assignees: Vec<ApiUser>,
232 #[serde(default)]
233 created_at: Option<DateTime<Utc>>,
234 #[serde(default)]
235 updated_at: Option<DateTime<Utc>>,
236 #[serde(default)]
237 web_url: Option<String>,
238 #[serde(default)]
239 milestone: Option<MilestoneRefApi>,
240}
241
242impl From<IssueApiResponse> for IssueData {
243 fn from(api: IssueApiResponse) -> Self {
244 let labels: Vec<Label> = api
245 .labels
246 .into_iter()
247 .map(|name| Label {
248 name,
249 color: None,
250 description: None,
251 })
252 .collect();
253 let author = api.author.as_ref().map_or_else(
254 || UserSummary {
255 login: "unknown".into(),
256 id: "0".to_string(),
257 },
258 UserSummary::from,
259 );
260
261 Self {
262 number: api.iid,
263 title: api.title,
264 body: api.description,
265 state: if api.state == "closed" {
266 State::Closed
267 } else {
268 State::Open
269 },
270 labels,
271 author,
272 assignees: api.assignees.iter().map(UserSummary::from).collect(),
273 created_at: api.created_at,
274 updated_at: api.updated_at,
275 url: api.web_url.unwrap_or_default(),
276 milestone: api.milestone.map(Into::into),
277 }
278 }
279}
280
281#[derive(Debug, Clone, Deserialize)]
283struct CommentApiResponse {
284 id: u64,
285 #[serde(default)]
286 body: String,
287 #[serde(default)]
288 author: Option<ApiUser>,
289 #[serde(default)]
290 created_at: Option<DateTime<Utc>>,
291}
292
293impl From<CommentApiResponse> for CommentData {
294 fn from(api: CommentApiResponse) -> Self {
295 let author = api.author.as_ref().map_or_else(
296 || UserSummary {
297 login: "unknown".into(),
298 id: "0".to_string(),
299 },
300 UserSummary::from,
301 );
302 Self {
303 id: api.id,
304 body: api.body,
305 author,
306 created_at: api.created_at,
307 }
308 }
309}
310
311impl<R: CommandRunner + Clone + 'static> GitLabIssueProvider<R> {
312 async fn list_impl(&self, args: ListIssueArgs) -> Result<Paged<IssueData>> {
317 let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
318 let repo_target = &self.repo_target;
319 let repo = &self.repo;
323 let runner = &self.runner;
324 let state = args.state;
325 let search = &args.search;
326 let labels = &args.labels;
327 let milestone = &args.milestone;
328 let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
331
332 debug!(repo = %self.repo, cap, "spawning `glab issue list`");
333
334 fetch_capped(
335 FetchStrategy::Paged { per_page },
336 cap,
337 |page, per_page| async move {
338 let page_str = page.to_string();
339 let per_page_str = per_page.to_string();
340 let mut cmd_args: Vec<&str> =
341 vec!["issue", "list", "--repo", repo_target, "--output", "json"];
342
343 if let Some(state) = &state {
345 match state {
346 State::Closed => cmd_args.push("--closed"),
347 State::All => cmd_args.push("--all"),
348 State::Open => {}
349 }
350 }
351
352 if let Some(search) = search {
353 cmd_args.push("--search");
354 cmd_args.push(search);
355 }
356
357 for label in labels {
358 cmd_args.push("--label");
359 cmd_args.push(label);
360 }
361
362 let resolved_milestone_title;
368 if let Some(identifier) = milestone {
369 let milestone_provider =
373 crate::GitLabMilestoneProvider::with_runner(repo.as_str(), runner.clone());
374 let resolved = gitflow_core::label::resolve_milestone_identifier(
375 &milestone_provider,
376 identifier,
377 )
378 .await?;
379 resolved_milestone_title = resolved.title;
380 cmd_args.push("--milestone");
381 cmd_args.push(&resolved_milestone_title);
382 }
383
384 cmd_args.push("--per-page");
385 cmd_args.push(&per_page_str);
386 cmd_args.push("--page");
387 cmd_args.push(&page_str);
388
389 let output = runner
390 .run("glab", &cmd_args)
391 .await
392 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
393
394 if !output.status.success() {
395 return Err(parse_glab_error(&output.stderr).into());
396 }
397
398 let api_responses: Vec<IssueApiResponse> =
399 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
400
401 Ok(api_responses.into_iter().map(IssueData::from).collect())
402 },
403 )
404 .await
405 }
406}
407
408#[async_trait]
411impl<R: CommandRunner + Clone + 'static> IssueProvider for GitLabIssueProvider<R> {
412 async fn create(&self, args: CreateIssueArgs) -> Result<IssueData> {
413 let labels_joined = args.labels.join(",");
414 let assignees_joined = args.assignees.join(",");
415 let description = args.body.clone().unwrap_or_default();
416
417 let mut cmd_args: Vec<&str> = vec![
418 "issue",
419 "create",
420 "--repo",
421 &self.repo_target,
422 "--title",
423 &args.title,
424 "--description",
425 &description,
426 ];
427
428 if !args.labels.is_empty() {
429 cmd_args.push("--label");
430 cmd_args.push(&labels_joined);
431 }
432
433 if !args.assignees.is_empty() {
434 cmd_args.push("--assignee");
435 cmd_args.push(&assignees_joined);
436 }
437
438 let resolved_milestone_title;
439 if let Some(identifier) = &args.milestone {
440 let milestone_provider = crate::GitLabMilestoneProvider::with_runner(
444 self.repo.as_str(),
445 self.runner.clone(),
446 );
447 let resolved =
448 gitflow_core::label::resolve_milestone_identifier(&milestone_provider, identifier)
449 .await?;
450 resolved_milestone_title = resolved.title;
451 cmd_args.push("--milestone");
452 cmd_args.push(&resolved_milestone_title);
453 }
454
455 debug!(repo = %self.repo, title = %args.title, "spawning `glab issue create`");
456
457 let output = self
458 .runner
459 .run("glab", &cmd_args)
460 .await
461 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
462
463 if !output.status.success() {
464 let missing = extract_missing_labels_from_error(&output.stderr);
467 if !missing.is_empty() {
468 debug!(
469 repo = %self.repo,
470 missing_count = missing.len(),
471 "auto-creating missing label(s) before retrying issue create"
472 );
473 for label in &missing {
474 self.ensure_label_exists(label).await?;
475 }
476
477 let retry_output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
478 CoreError::Platform(format!("Failed to spawn glab on retry: {e}"))
479 })?;
480
481 if !retry_output.status.success() {
482 return Err(parse_glab_error(&retry_output.stderr).into());
483 }
484
485 let stdout = String::from_utf8_lossy(&retry_output.stdout);
486 let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
487 CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
488 })?;
489 return self.view(issue_iid).await;
490 }
491
492 return Err(parse_glab_error(&output.stderr).into());
493 }
494
495 let stdout = String::from_utf8_lossy(&output.stdout);
497 let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
498 CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
499 })?;
500
501 self.view(issue_iid).await
503 }
504
505 async fn edit(&self, number: u64, args: EditIssueArgs) -> Result<IssueData> {
515 debug!(repo = %self.repo, number, "spawning `glab issue update`");
516
517 let number_str = number.to_string();
518 let mut cmd_args: Vec<&str> =
519 vec!["issue", "update", &number_str, "--repo", &self.repo_target];
520
521 if let Some(title) = &args.title {
522 cmd_args.push("--title");
523 cmd_args.push(title);
524 }
525 if let Some(body) = &args.body {
526 cmd_args.push("--description");
527 cmd_args.push(body);
528 }
529
530 let resolved_milestone_title;
531 match &args.milestone {
532 None => {}
533 Some(None) => {
534 cmd_args.push("--milestone");
538 cmd_args.push("");
539 }
540 Some(Some(identifier)) => {
541 let milestone_provider = crate::GitLabMilestoneProvider::with_runner(
544 self.repo.as_str(),
545 self.runner.clone(),
546 );
547 let resolved = gitflow_core::label::resolve_milestone_identifier(
548 &milestone_provider,
549 identifier,
550 )
551 .await?;
552 resolved_milestone_title = resolved.title;
553 cmd_args.push("--milestone");
554 cmd_args.push(&resolved_milestone_title);
555 }
556 }
557
558 let output = self
559 .runner
560 .run("glab", &cmd_args)
561 .await
562 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
563
564 if !output.status.success() {
565 return Err(parse_glab_error(&output.stderr).into());
566 }
567
568 self.view(number).await
569 }
570
571 async fn list(&self, args: ListIssueArgs) -> Result<Paged<IssueData>> {
572 self.list_impl(args).await
573 }
574
575 async fn view(&self, number: u64) -> Result<IssueData> {
576 debug!(repo = %self.repo, number, "spawning `glab issue view`");
577
578 let number_str = number.to_string();
579 let output = self
580 .runner
581 .run(
582 "glab",
583 &[
584 "issue",
585 "view",
586 &number_str,
587 "--repo",
588 &self.repo_target,
589 "--output",
590 "json",
591 ],
592 )
593 .await
594 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
595
596 if !output.status.success() {
597 return Err(parse_glab_error(&output.stderr).into());
598 }
599
600 let api_response: IssueApiResponse =
601 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
602
603 Ok(api_response.into())
604 }
605
606 async fn close(&self, number: u64) -> Result<IssueData> {
615 debug!(repo = %self.repo, number, "spawning `glab issue close`");
616
617 let number_str = number.to_string();
618 let output = self
619 .runner
620 .run(
621 "glab",
622 &["issue", "close", &number_str, "--repo", &self.repo_target],
623 )
624 .await
625 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
626
627 if !output.status.success() {
628 return Err(parse_glab_error(&output.stderr).into());
629 }
630
631 self.view(number).await
632 }
633
634 async fn reopen(&self, number: u64) -> Result<IssueData> {
643 debug!(repo = %self.repo, number, "spawning `glab issue reopen`");
644
645 let number_str = number.to_string();
646 let output = self
647 .runner
648 .run(
649 "glab",
650 &["issue", "reopen", &number_str, "--repo", &self.repo_target],
651 )
652 .await
653 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
654
655 if !output.status.success() {
656 return Err(parse_glab_error(&output.stderr).into());
657 }
658
659 self.view(number).await
660 }
661
662 async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
673 debug!(repo = %self.repo, number, "spawning `glab api` POST issue note");
674
675 let encoded_path = encode_project_path(&self.repo);
676 let api_path = format!("/projects/{encoded_path}/issues/{number}/notes");
677 let body_arg = format!("body={body}");
678
679 let output = self
680 .runner
681 .run(
682 "glab",
683 &["api", "--method", "POST", &api_path, "-f", &body_arg],
684 )
685 .await
686 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
687
688 if !output.status.success() {
689 return Err(parse_glab_error(&output.stderr).into());
690 }
691
692 let api_response: CommentApiResponse =
693 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
694
695 Ok(api_response.into())
696 }
697
698 async fn list_comments(&self, number: u64, limit: Option<u32>) -> Result<Paged<CommentData>> {
709 let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
710 let encoded_path = encode_project_path(&self.repo);
711 let encoded_path = &encoded_path;
712 let runner = &self.runner;
713 let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
714
715 debug!(repo = %self.repo, number, cap, "spawning `glab api` GET issue notes");
716
717 fetch_capped(
718 FetchStrategy::Paged { per_page },
719 cap,
720 |page, per_page| async move {
721 let api_path = format!(
722 "/projects/{encoded_path}/issues/{number}/notes?per_page={per_page}&\
723 page={page}"
724 );
725
726 let output = runner
727 .run("glab", &["api", &api_path])
728 .await
729 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
730
731 if !output.status.success() {
732 return Err(parse_glab_error(&output.stderr).into());
733 }
734
735 let comments: Vec<CommentApiResponse> =
736 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
737 Ok(comments.into_iter().map(CommentData::from).collect())
738 },
739 )
740 .await
741 }
742
743 async fn add_labels(&self, number: u64, labels: &[String]) -> Result<()> {
757 debug!(
758 repo = %self.repo,
759 number,
760 label_count = labels.len(),
761 "spawning `glab issue update --label`"
762 );
763
764 let labels_joined = labels.join(",");
765 let number_str = number.to_string();
766 let cmd_args: Vec<&str> = vec![
767 "issue",
768 "update",
769 &number_str,
770 "--repo",
771 &self.repo_target,
772 "--label",
773 &labels_joined,
774 ];
775 let output = self
776 .runner
777 .run("glab", &cmd_args)
778 .await
779 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
780
781 if output.status.success() {
782 return Ok(());
783 }
784
785 let missing = extract_missing_labels_from_error(&output.stderr);
788 if missing.is_empty() {
789 return Err(parse_glab_error(&output.stderr).into());
790 }
791
792 debug!(
793 repo = %self.repo,
794 missing_count = missing.len(),
795 "auto-creating missing label(s) before retry"
796 );
797
798 for label in &missing {
799 self.ensure_label_exists(label).await?;
800 }
801
802 let retry_output = self
803 .runner
804 .run("glab", &cmd_args)
805 .await
806 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab on retry: {e}")))?;
807
808 if !retry_output.status.success() {
809 return Err(parse_glab_error(&retry_output.stderr).into());
810 }
811
812 Ok(())
813 }
814
815 async fn remove_label(&self, number: u64, label: &str) -> Result<()> {
823 debug!(repo = %self.repo, number, label, "spawning `glab issue update --unlabel`");
824
825 let number_str = number.to_string();
826 let output = self
827 .runner
828 .run(
829 "glab",
830 &[
831 "issue",
832 "update",
833 &number_str,
834 "--repo",
835 &self.repo_target,
836 "--unlabel",
837 label,
838 ],
839 )
840 .await
841 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
842
843 if !output.status.success() {
844 return Err(parse_glab_error(&output.stderr).into());
845 }
846
847 Ok(())
848 }
849}
850
851fn extract_missing_labels_from_error(stderr: &[u8]) -> Vec<String> {
857 let text = String::from_utf8_lossy(stderr);
858 let mut labels = Vec::new();
859 let mut search_from: usize = 0;
860
861 while let Some(rel_open) = text[search_from..].find('\'') {
863 let open_pos = search_from + rel_open + 1;
864 let Some(rel_close) = text[open_pos..].find('\'') else {
865 break;
866 };
867 let close_pos = open_pos + rel_close;
868 let after_close = &text[close_pos + 1..];
869
870 if after_close.starts_with(" not found") {
871 let label = text[open_pos..close_pos].to_string();
872 if !label.is_empty() {
873 labels.push(label);
874 }
875 }
876 search_from = close_pos + 1;
877 }
878
879 labels
880}
881
882fn parse_issue_iid_from_url(url: &str) -> Option<u64> {
889 url.lines().find_map(|line| {
890 let line = line.trim();
891 for marker in ["/-/issues/", "/-/work_items/"] {
892 if line.contains(marker)
893 && let Some(id) = line
894 .rsplit(marker)
895 .next()
896 .and_then(|s| s.split('/').next())
897 .and_then(|s| s.parse().ok())
898 {
899 return Some(id);
900 }
901 }
902 None
903 })
904}
905
906#[cfg(test)]
907mod tests {
908 use super::*;
909 use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
910
911 #[test]
912 fn test_should_construct_gitlab_issue_provider() {
913 let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
914 assert_eq!(provider.repo, "gitlab-org/gitlab");
915 }
916
917 #[test]
918 fn test_should_construct_gitlab_issue_provider_from_string() {
919 let repo = String::from("gitlab-org/gitlab");
920 let provider = GitLabIssueProvider::new(repo);
921 assert_eq!(provider.repo, "gitlab-org/gitlab");
922 }
923
924 #[test]
925 fn test_should_deserialize_issue_api_response() {
926 let json = br#"{
927 "iid": 42,
928 "title": "Fix login bug",
929 "description": "Reproduced on v1.2.3",
930 "state": "opened",
931 "labels": ["bug", "critical"],
932 "author": {"username": "admin", "id": 1},
933 "assignees": [{"username": "alice", "id": 7}],
934 "created_at": "2026-01-15T09:30:00Z",
935 "updated_at": "2026-01-16T11:00:00Z",
936 "web_url": "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
937 }"#;
938
939 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
940 let issue: IssueData = api.into();
941
942 assert_eq!(issue.number, 42);
943 assert_eq!(issue.title, "Fix login bug");
944 assert_eq!(issue.body.as_deref(), Some("Reproduced on v1.2.3"));
945 assert_eq!(issue.state, State::Open);
946 assert_eq!(issue.labels.len(), 2);
947 assert_eq!(issue.labels[0].name, "bug");
948 assert_eq!(issue.author.login, "admin");
949 assert_eq!(issue.assignees.len(), 1);
950 assert_eq!(
951 issue.url,
952 "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
953 );
954 }
955
956 #[test]
957 fn test_should_deserialize_closed_issue_api_response() {
958 let json = br#"{
959 "iid": 10,
960 "title": "Fixed typo",
961 "description": null,
962 "state": "closed",
963 "labels": [],
964 "author": {"username": "dev", "id": 5},
965 "assignees": [],
966 "created_at": "2026-06-01T08:00:00Z",
967 "updated_at": "2026-06-02T12:00:00Z",
968 "web_url": "https://gitlab.com/org/project/-/issues/10"
969 }"#;
970
971 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
972 let issue: IssueData = api.into();
973 assert_eq!(issue.state, State::Closed);
974 }
975
976 #[test]
977 fn test_should_deserialize_comment_api_response() {
978 let json = br#"{
979 "id": 1001,
980 "body": "Thanks for reporting.",
981 "author": {"username": "maintainer", "id": 42},
982 "created_at": "2026-06-15T14:00:00Z"
983 }"#;
984
985 let api: CommentApiResponse =
986 serde_json::from_slice(json).expect("valid CommentApiResponse");
987 let comment: CommentData = api.into();
988 assert_eq!(comment.id, 1001);
989 assert_eq!(comment.body, "Thanks for reporting.");
990 assert_eq!(comment.author.login, "maintainer");
991 }
992
993 #[test]
994 fn test_should_handle_missing_author_with_fallback() {
995 let json = br#"{
996 "iid": 1,
997 "title": "No author",
998 "description": null,
999 "state": "opened",
1000 "labels": [],
1001 "author": null,
1002 "assignees": [],
1003 "created_at": null,
1004 "updated_at": null,
1005 "web_url": null
1006 }"#;
1007
1008 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
1009 let issue: IssueData = api.into();
1010 assert_eq!(issue.author.login, "unknown");
1011 assert_eq!(issue.author.id, "0");
1012 assert!(
1013 issue.created_at.is_none(),
1014 "missing created_at must stay None, not fall back to Utc::now()"
1015 );
1016 assert!(
1017 issue.updated_at.is_none(),
1018 "missing updated_at must stay None, not fall back to Utc::now()"
1019 );
1020 }
1021
1022 #[test]
1023 fn test_should_keep_comment_created_at_none_when_api_omits_it() {
1024 let json = br#"{
1025 "id": 1002,
1026 "body": "No timestamp provided.",
1027 "author": {"username": "maintainer", "id": 42}
1028 }"#;
1029
1030 let api: CommentApiResponse =
1031 serde_json::from_slice(json).expect("valid CommentApiResponse");
1032 let comment: CommentData = api.into();
1033 assert!(
1034 comment.created_at.is_none(),
1035 "missing created_at must stay None, not fall back to Utc::now()"
1036 );
1037 }
1038
1039 #[test]
1040 fn test_should_convert_labels_from_strings() {
1041 let json = br#"{
1042 "iid": 1,
1043 "title": "Test",
1044 "description": null,
1045 "state": "opened",
1046 "labels": ["bug", "enhancement", "documentation"],
1047 "author": {"username": "admin", "id": 1},
1048 "assignees": [],
1049 "created_at": "2026-01-01T00:00:00Z",
1050 "updated_at": "2026-01-01T00:00:00Z",
1051 "web_url": "https://gitlab.com/x/y/-/issues/1"
1052 }"#;
1053
1054 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
1055 let issue: IssueData = api.into();
1056 assert_eq!(issue.labels.len(), 3);
1057 assert_eq!(issue.labels[0].name, "bug");
1058 assert_eq!(issue.labels[1].name, "enhancement");
1059 assert!(issue.labels[0].color.is_none());
1060 }
1061
1062 #[test]
1063 fn test_should_deserialize_issue_with_milestone() {
1064 let json = r#"{
1071 "iid": 10,
1072 "title": "gf-357 milestone test issue",
1073 "description": "temp test issue for milestone shape investigation",
1074 "state": "opened",
1075 "labels": [],
1076 "milestone": {
1077 "id": 2,
1078 "iid": 2,
1079 "title": "gf-357-test-milestone",
1080 "state": "active"
1081 },
1082 "web_url": "http://192.168.230.23/iproost/iproost-docs/-/work_items/10"
1083 }"#;
1084 let api: IssueApiResponse = serde_json::from_str(json).expect("deserialize");
1085 let issue: IssueData = api.into();
1086 assert_eq!(
1087 issue.milestone,
1088 Some(gitflow_core::types::MilestoneRef {
1089 number: 2,
1090 title: "gf-357-test-milestone".into(),
1091 })
1092 );
1093 }
1094
1095 #[test]
1096 fn test_should_deserialize_issue_with_no_milestone_field() {
1097 let json = r#"{
1098 "iid": 11,
1099 "title": "No milestone",
1100 "description": null,
1101 "state": "opened",
1102 "labels": [],
1103 "web_url": "http://192.168.230.23/iproost/iproost-docs/-/issues/11"
1104 }"#;
1105 let api: IssueApiResponse = serde_json::from_str(json).expect("deserialize");
1106 let issue: IssueData = api.into();
1107 assert!(issue.milestone.is_none());
1108 }
1109
1110 #[test]
1111 fn test_should_deserialize_empty_issue_list() {
1112 let json = b"[]";
1113 let list: Vec<IssueApiResponse> = serde_json::from_slice(json).expect("valid empty list");
1114 assert!(list.is_empty());
1115 }
1116
1117 #[test]
1118 fn test_should_debug_format_provider() {
1119 let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
1120 let debug = format!("{provider:?}");
1121 assert!(debug.contains("GitLabIssueProvider"));
1122 assert!(debug.contains("gitlab-org/gitlab"));
1123 }
1124
1125 #[test]
1126 fn test_should_clone_gitlab_issue_provider() {
1127 let original = GitLabIssueProvider::new("owner/repo");
1128 let cloned = original.clone();
1129 assert_eq!(original.repo, cloned.repo);
1130 }
1131
1132 #[test]
1133 fn test_should_parse_issue_iid_from_gitlab_url() {
1134 assert_eq!(
1135 parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/123"),
1136 Some(123)
1137 );
1138 }
1139
1140 #[test]
1141 fn test_should_parse_issue_iid_from_self_hosted_url() {
1142 assert_eq!(
1143 parse_issue_iid_from_url("https://gitlab.example.com/group/project/-/issues/456"),
1144 Some(456)
1145 );
1146 }
1147
1148 #[test]
1149 fn test_should_parse_issue_iid_from_multiline_output() {
1150 let output = "Creating issue...\nhttps://gitlab.com/owner/repo/-/issues/789\nDone.";
1151 assert_eq!(parse_issue_iid_from_url(output), Some(789));
1152 }
1153
1154 #[test]
1155 fn test_should_return_none_for_invalid_url() {
1156 assert_eq!(parse_issue_iid_from_url("not a url"), None);
1157 }
1158
1159 #[test]
1160 fn test_should_return_none_for_url_without_iid() {
1161 assert_eq!(
1162 parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/"),
1163 None
1164 );
1165 }
1166
1167 #[test]
1168 fn test_should_parse_work_item_url() {
1169 assert_eq!(
1170 parse_issue_iid_from_url("http://192.168.230.23/iproost/iproost-docs/-/work_items/1"),
1171 Some(1)
1172 );
1173 }
1174
1175 #[test]
1176 fn test_should_parse_work_item_url_among_lines() {
1177 let output =
1178 "Creating issue...\nhttp://192.168.230.23/iproost/iproost-docs/-/work_items/7\nDone.";
1179 assert_eq!(parse_issue_iid_from_url(output), Some(7));
1180 }
1181
1182 #[tokio::test]
1185 async fn test_should_return_platform_error_when_glab_fails_for_view() {
1186 let runner = MockCommandRunner::failure(r#"{"message": "Issue not found"}"#, 256);
1187 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1188
1189 let result = provider.view(999).await;
1190
1191 assert!(result.is_err());
1192 assert!(matches!(
1193 result.unwrap_err(),
1194 gitflow_core::CoreError::Cli(_)
1195 ));
1196 }
1197
1198 #[tokio::test]
1199 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
1200 let runner = MockCommandRunner::success("not valid json");
1201 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1202
1203 let result = provider.view(1).await;
1204
1205 assert!(result.is_err());
1206 assert!(matches!(
1207 result.unwrap_err(),
1208 gitflow_core::CoreError::Serialization(_)
1209 ));
1210 }
1211
1212 #[tokio::test]
1213 async fn test_should_return_platform_error_when_glab_fails_for_list() {
1214 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
1215 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1216
1217 let result = provider.list(ListIssueArgs::default()).await;
1218
1219 assert!(result.is_err());
1220 assert!(matches!(
1221 result.unwrap_err(),
1222 gitflow_core::CoreError::Cli(_)
1223 ));
1224 }
1225
1226 #[tokio::test]
1227 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
1228 let runner = MockCommandRunner::success("invalid");
1229 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1230
1231 let result = provider.list(ListIssueArgs::default()).await;
1232
1233 assert!(result.is_err());
1234 assert!(matches!(
1235 result.unwrap_err(),
1236 gitflow_core::CoreError::Serialization(_)
1237 ));
1238 }
1239
1240 #[tokio::test]
1241 async fn test_should_list_all_issues_with_all_flag() {
1242 let runner = MockCommandRunner::success("[]");
1243 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1244
1245 let _ = provider
1246 .list(ListIssueArgs {
1247 state: Some(State::All),
1248 ..Default::default()
1249 })
1250 .await;
1251
1252 assert_eq!(
1253 runner.recorded_calls()[0].1,
1254 vec![
1255 "issue",
1256 "list",
1257 "--repo",
1258 "owner/repo",
1259 "--output",
1260 "json",
1261 "--all",
1262 "--per-page",
1263 "100",
1264 "--page",
1265 "1"
1266 ]
1267 .into_iter()
1268 .map(String::from)
1269 .collect::<Vec<_>>()
1270 );
1271 }
1272
1273 fn sample_create_args() -> CreateIssueArgs {
1274 CreateIssueArgs {
1275 title: "Bug report".to_string(),
1276 body: Some("Steps to reproduce".to_string()),
1277 labels: vec!["bug".to_string()],
1278 assignees: vec!["alice".to_string()],
1279 milestone: None,
1280 }
1281 }
1282
1283 #[tokio::test]
1284 async fn test_should_pass_empty_description_when_body_is_none() {
1285 let runner = SequencedMockCommandRunner::from_results(&[
1286 (true, "https://gitlab.com/owner/repo/-/issues/7"),
1287 (true, r#"{"iid":7,"title":"t","state":"opened"}"#),
1288 ]);
1289 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1290
1291 let args = CreateIssueArgs {
1292 title: "t".to_string(),
1293 body: None,
1294 labels: vec![],
1295 assignees: vec![],
1296 milestone: None,
1297 };
1298
1299 provider.create(args).await.expect("should create");
1300
1301 let calls = runner.recorded_calls();
1302 let create_call = &calls[0];
1303 let desc_idx = create_call
1304 .1
1305 .iter()
1306 .position(|a| a == "--description")
1307 .expect("--description flag must be present even when body is None");
1308 assert_eq!(create_call.1[desc_idx + 1], "");
1309 }
1310
1311 #[tokio::test]
1312 async fn test_should_return_platform_error_when_glab_fails_for_create() {
1313 let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
1314 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1315
1316 let result = provider.create(sample_create_args()).await;
1317
1318 assert!(result.is_err());
1319 assert!(matches!(
1320 result.unwrap_err(),
1321 gitflow_core::CoreError::Cli(_)
1322 ));
1323 }
1324
1325 #[tokio::test]
1326 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
1327 let runner = MockCommandRunner::success("https://gitlab.com/owner/repo/-/issues/7");
1330 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1331
1332 let result = provider.create(sample_create_args()).await;
1333
1334 assert!(result.is_err());
1335 assert!(matches!(
1336 result.unwrap_err(),
1337 gitflow_core::CoreError::Serialization(_)
1338 ));
1339 }
1340
1341 #[tokio::test]
1342 async fn test_should_return_platform_error_when_glab_fails_for_close() {
1343 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1344 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1345
1346 let result = provider.close(42).await;
1347
1348 assert!(result.is_err());
1349 assert!(matches!(
1350 result.unwrap_err(),
1351 gitflow_core::CoreError::Cli(_)
1352 ));
1353 }
1354
1355 #[tokio::test]
1356 async fn test_should_return_serialization_error_on_invalid_json_for_close() {
1357 let runner = MockCommandRunner::success("invalid");
1358 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1359
1360 let result = provider.close(42).await;
1361
1362 assert!(result.is_err());
1363 assert!(matches!(
1364 result.unwrap_err(),
1365 gitflow_core::CoreError::Serialization(_)
1366 ));
1367 }
1368
1369 #[tokio::test]
1370 async fn test_should_return_platform_error_when_glab_fails_for_reopen() {
1371 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1372 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1373
1374 let result = provider.reopen(42).await;
1375
1376 assert!(result.is_err());
1377 assert!(matches!(
1378 result.unwrap_err(),
1379 gitflow_core::CoreError::Cli(_)
1380 ));
1381 }
1382
1383 #[tokio::test]
1384 async fn test_should_return_serialization_error_on_invalid_json_for_reopen() {
1385 let runner = MockCommandRunner::success("invalid");
1386 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1387
1388 let result = provider.reopen(42).await;
1389
1390 assert!(result.is_err());
1391 assert!(matches!(
1392 result.unwrap_err(),
1393 gitflow_core::CoreError::Serialization(_)
1394 ));
1395 }
1396
1397 #[tokio::test]
1398 async fn test_should_close_issue_without_output_json_flag_and_refetch_via_view() {
1399 let runner = MockCommandRunner::success(
1400 r#"{"iid":42,"title":"Fix","state":"closed","description":null,"labels":[]}"#,
1401 );
1402 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1403
1404 let issue = provider.close(42).await.expect("close should succeed");
1405
1406 assert_eq!(issue.number, 42);
1407 assert_eq!(issue.state, State::Closed);
1408 let calls = runner.recorded_calls();
1409 assert_eq!(
1410 calls[0].1,
1411 vec!["issue", "close", "42", "--repo", "owner/repo"]
1412 .into_iter()
1413 .map(String::from)
1414 .collect::<Vec<_>>()
1415 );
1416 assert_eq!(calls[1].0, "glab");
1418 assert!(calls[1].1.contains(&"--output".to_string()));
1419 }
1420
1421 #[tokio::test]
1422 async fn test_should_reopen_issue_without_output_json_flag_and_refetch_via_view() {
1423 let runner = MockCommandRunner::success(
1424 r#"{"iid":42,"title":"Fix","state":"opened","description":null,"labels":[]}"#,
1425 );
1426 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1427
1428 let issue = provider.reopen(42).await.expect("reopen should succeed");
1429
1430 assert_eq!(issue.number, 42);
1431 assert_eq!(issue.state, State::Open);
1432 let calls = runner.recorded_calls();
1433 assert_eq!(
1434 calls[0].1,
1435 vec!["issue", "reopen", "42", "--repo", "owner/repo"]
1436 .into_iter()
1437 .map(String::from)
1438 .collect::<Vec<_>>()
1439 );
1440 assert!(calls[1].1.contains(&"--output".to_string()));
1441 }
1442
1443 #[tokio::test]
1444 async fn test_should_use_explicit_repo_target_for_view() {
1445 let runner = MockCommandRunner::success(
1446 r#"{"iid":42,"title":"Fix","state":"opened","description":null,"labels":[]}"#,
1447 );
1448 let provider = GitLabIssueProvider::with_runner_and_repo_target(
1449 "owner/repo",
1450 "https://192.168.230.23/iproost/proxy/api-src.git",
1451 runner.clone(),
1452 );
1453
1454 let issue = provider.view(42).await.expect("view should succeed");
1455
1456 assert_eq!(issue.number, 42);
1457 assert!(
1458 runner.recorded_calls()[0]
1459 .1
1460 .contains(&"https://192.168.230.23/iproost/proxy/api-src.git".to_string())
1461 );
1462 }
1463
1464 #[tokio::test]
1465 async fn test_should_return_platform_error_when_glab_fails_for_comment() {
1466 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1467 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1468
1469 let result = provider.comment(42, "a comment").await;
1470
1471 assert!(result.is_err());
1472 assert!(matches!(
1473 result.unwrap_err(),
1474 gitflow_core::CoreError::Cli(_)
1475 ));
1476 }
1477
1478 #[tokio::test]
1479 async fn test_should_return_serialization_error_on_invalid_json_for_comment() {
1480 let runner = MockCommandRunner::success("invalid");
1481 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1482
1483 let result = provider.comment(42, "a comment").await;
1484
1485 assert!(result.is_err());
1486 assert!(matches!(
1487 result.unwrap_err(),
1488 gitflow_core::CoreError::Serialization(_)
1489 ));
1490 }
1491
1492 #[tokio::test]
1493 async fn test_should_post_issue_note_via_glab_api_with_message_field() {
1494 let runner = MockCommandRunner::success(
1495 r#"{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}"#,
1496 );
1497 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1498
1499 let comment = provider.comment(42, "hello").await.expect("should post");
1500
1501 assert_eq!(comment.id, 77);
1502 assert_eq!(comment.author.login, "alice");
1503 assert_eq!(
1504 runner.recorded_calls()[0].1,
1505 vec![
1506 "api",
1507 "--method",
1508 "POST",
1509 "/projects/owner%2Frepo/issues/42/notes",
1510 "-f",
1511 "body=hello",
1512 ]
1513 .into_iter()
1514 .map(String::from)
1515 .collect::<Vec<_>>()
1516 );
1517 }
1518
1519 #[tokio::test]
1520 async fn test_should_encode_nested_group_repo_path_for_comment() {
1521 let runner = MockCommandRunner::success(
1522 r#"{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}"#,
1523 );
1524 let provider = GitLabIssueProvider::with_runner("group/subgroup/project", runner.clone());
1525
1526 let comment = provider.comment(42, "hello").await.expect("should post");
1527
1528 assert_eq!(comment.id, 77);
1529 assert_eq!(
1530 runner.recorded_calls()[0].1,
1531 vec![
1532 "api",
1533 "--method",
1534 "POST",
1535 "/projects/group%2Fsubgroup%2Fproject/issues/42/notes",
1536 "-f",
1537 "body=hello",
1538 ]
1539 .into_iter()
1540 .map(String::from)
1541 .collect::<Vec<_>>()
1542 );
1543 }
1544
1545 #[tokio::test]
1546 async fn test_should_encode_nested_group_repo_path_for_list_comments() {
1547 let runner = MockCommandRunner::success(
1548 r#"[{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}]"#,
1549 );
1550 let provider = GitLabIssueProvider::with_runner("group/subgroup/project", runner.clone());
1551
1552 let paged = provider.list_comments(42, None).await.expect("should list");
1553
1554 assert_eq!(paged.items.len(), 1);
1555 assert_eq!(
1556 runner.recorded_calls()[0].1,
1557 vec![
1558 "api",
1559 "/projects/group%2Fsubgroup%2Fproject/issues/42/notes?per_page=100&page=1"
1560 ]
1561 .into_iter()
1562 .map(String::from)
1563 .collect::<Vec<_>>()
1564 );
1565 }
1566
1567 #[tokio::test]
1568 async fn test_should_produce_complete_argv_for_list_comments_with_default_limit() {
1569 let runner = MockCommandRunner::success("[]");
1570 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1571
1572 let paged = provider
1573 .list_comments(359, None)
1574 .await
1575 .expect("list_comments should succeed");
1576
1577 assert!(paged.items.is_empty());
1578 let calls = runner.recorded_calls();
1579 assert_eq!(calls[0].0, "glab");
1580 assert_eq!(
1581 calls[0].1,
1582 vec![
1583 "api",
1584 "/projects/owner%2Frepo/issues/359/notes?per_page=100&page=1"
1585 ]
1586 );
1587 }
1588
1589 #[tokio::test]
1590 async fn test_should_build_well_formed_query_string_for_list_comments() {
1591 let runner = MockCommandRunner::success("[]");
1592 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1593
1594 provider
1595 .list_comments(359, None)
1596 .await
1597 .expect("list_comments should succeed");
1598
1599 let calls = runner.recorded_calls();
1600 let api_path = &calls[0].1[1];
1601 assert_eq!(
1602 api_path.matches('?').count(),
1603 1,
1604 "must have exactly one '?', got: {api_path}"
1605 );
1606 assert_eq!(
1607 api_path.matches('&').count(),
1608 1,
1609 "must have exactly one '&', got: {api_path}"
1610 );
1611 assert!(api_path.contains("per_page=100"), "got: {api_path}");
1612 assert!(api_path.contains("page=1"), "got: {api_path}");
1613 }
1614
1615 #[tokio::test]
1616 async fn test_should_return_platform_error_when_glab_fails_for_add_labels() {
1617 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1618 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1619
1620 let result = provider.add_labels(42, &["bug".to_string()]).await;
1621
1622 assert!(result.is_err());
1623 assert!(matches!(
1624 result.unwrap_err(),
1625 gitflow_core::CoreError::Cli(_)
1626 ));
1627 }
1628
1629 #[tokio::test]
1630 async fn test_should_return_platform_error_when_glab_fails_for_remove_label() {
1631 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1632 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1633
1634 let result = provider.remove_label(42, "bug").await;
1635
1636 assert!(result.is_err());
1637 assert!(matches!(
1638 result.unwrap_err(),
1639 gitflow_core::CoreError::Cli(_)
1640 ));
1641 }
1642
1643 #[tokio::test]
1644 async fn test_should_call_issue_update_with_label_flag_for_add_labels() {
1645 let runner = MockCommandRunner::success("");
1646 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1647
1648 let result = provider
1649 .add_labels(42, &["bug".to_string(), "priority:high".to_string()])
1650 .await;
1651
1652 assert!(result.is_ok(), "expected Ok, got {result:?}");
1653 assert_eq!(
1654 runner.recorded_calls()[0].1,
1655 vec![
1656 "issue",
1657 "update",
1658 "42",
1659 "--repo",
1660 "owner/repo",
1661 "--label",
1662 "bug,priority:high"
1663 ]
1664 .into_iter()
1665 .map(String::from)
1666 .collect::<Vec<_>>()
1667 );
1668 }
1669
1670 #[tokio::test]
1671 async fn test_should_use_explicit_repo_target_for_add_labels() {
1672 let runner = MockCommandRunner::success("");
1673 let provider = GitLabIssueProvider::with_runner_and_repo_target(
1674 "owner/repo",
1675 "https://192.168.230.23/iproost/proxy/api-src.git",
1676 runner.clone(),
1677 );
1678
1679 let result = provider
1680 .add_labels(42, &["priority:medium".to_string()])
1681 .await;
1682
1683 assert!(result.is_ok(), "expected Ok, got {result:?}");
1684 assert_eq!(
1685 runner.recorded_calls()[0].1,
1686 vec![
1687 "issue",
1688 "update",
1689 "42",
1690 "--repo",
1691 "https://192.168.230.23/iproost/proxy/api-src.git",
1692 "--label",
1693 "priority:medium",
1694 ]
1695 .into_iter()
1696 .map(String::from)
1697 .collect::<Vec<_>>()
1698 );
1699 }
1700
1701 #[tokio::test]
1702 async fn test_should_call_issue_update_with_unlabel_flag_for_remove_label() {
1703 let runner = MockCommandRunner::success("");
1704 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1705
1706 let result = provider.remove_label(42, "bug").await;
1707
1708 assert!(result.is_ok(), "expected Ok, got {result:?}");
1709 assert_eq!(
1710 runner.recorded_calls()[0].1,
1711 vec![
1712 "issue",
1713 "update",
1714 "42",
1715 "--repo",
1716 "owner/repo",
1717 "--unlabel",
1718 "bug"
1719 ]
1720 .into_iter()
1721 .map(String::from)
1722 .collect::<Vec<_>>()
1723 );
1724 }
1725
1726 #[tokio::test]
1727 async fn test_should_use_explicit_repo_target_for_remove_label() {
1728 let runner = MockCommandRunner::success("");
1729 let provider = GitLabIssueProvider::with_runner_and_repo_target(
1730 "owner/repo",
1731 "https://192.168.230.23/iproost/proxy/api-src.git",
1732 runner.clone(),
1733 );
1734
1735 let result = provider.remove_label(42, "priority:medium").await;
1736
1737 assert!(result.is_ok(), "expected Ok, got {result:?}");
1738 assert_eq!(
1739 runner.recorded_calls()[0].1,
1740 vec![
1741 "issue",
1742 "update",
1743 "42",
1744 "--repo",
1745 "https://192.168.230.23/iproost/proxy/api-src.git",
1746 "--unlabel",
1747 "priority:medium",
1748 ]
1749 .into_iter()
1750 .map(String::from)
1751 .collect::<Vec<_>>()
1752 );
1753 }
1754
1755 #[tokio::test]
1756 async fn test_should_edit_issue_via_update_and_view_result() {
1757 let runner = SequencedMockCommandRunner::from_results(&[
1760 (true, ""),
1761 (
1762 true,
1763 r#"{"iid":42,"title":"New title","description":"orig","state":"opened","labels":[],"author":{"username":"admin","id":1},"assignees":[],"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-02T00:00:00Z","web_url":"https://gitlab.com/owner/repo/-/issues/42"}"#,
1764 ),
1765 ]);
1766 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1767
1768 let issue = provider
1769 .edit(
1770 42,
1771 gitflow_core::issue::EditIssueArgs {
1772 title: Some("New title".to_string()),
1773 body: None,
1774 milestone: None,
1775 },
1776 )
1777 .await
1778 .expect("edit should succeed");
1779
1780 assert_eq!(issue.number, 42);
1781 assert_eq!(issue.title, "New title");
1782 }
1783
1784 #[tokio::test]
1785 async fn test_should_send_title_and_description_flags_for_edit() {
1786 let runner = MockCommandRunner::success("");
1787 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1788
1789 let _ = provider
1790 .edit(
1791 7,
1792 gitflow_core::issue::EditIssueArgs {
1793 title: Some("T".to_string()),
1794 body: Some("B".to_string()),
1795 milestone: None,
1796 },
1797 )
1798 .await;
1799
1800 assert_eq!(
1801 runner.recorded_calls()[0].1,
1802 vec![
1803 "issue",
1804 "update",
1805 "7",
1806 "--repo",
1807 "owner/repo",
1808 "--title",
1809 "T",
1810 "--description",
1811 "B"
1812 ]
1813 .into_iter()
1814 .map(String::from)
1815 .collect::<Vec<_>>()
1816 );
1817 }
1818
1819 #[tokio::test]
1820 async fn test_should_return_platform_error_when_glab_fails_for_edit() {
1821 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1822 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1823
1824 let result = provider
1825 .edit(42, gitflow_core::issue::EditIssueArgs::default())
1826 .await;
1827
1828 assert!(result.is_err());
1829 assert!(matches!(
1830 result.unwrap_err(),
1831 gitflow_core::CoreError::Cli(_)
1832 ));
1833 }
1834
1835 #[test]
1838 fn test_should_extract_single_missing_label_from_glab_stderr() {
1839 let stderr = b"failed to update ...: 'type:enhancement' not found";
1840 let missing = extract_missing_labels_from_error(stderr);
1841 assert_eq!(missing, vec!["type:enhancement".to_string()]);
1842 }
1843
1844 #[test]
1845 fn test_should_return_empty_when_no_label_not_found_in_glab_stderr() {
1846 let stderr = b"glab: Not logged in";
1847 let missing = extract_missing_labels_from_error(stderr);
1848 assert!(missing.is_empty());
1849 }
1850
1851 #[tokio::test]
1854 async fn test_should_auto_create_label_and_retry_on_add_labels_glab() {
1855 let runner = SequencedMockCommandRunner::from_results(&[
1856 (false, "failed to update ...: 'type:enhancement' not found"),
1857 (true, "Created label type:enhancement"),
1858 (true, ""),
1859 ]);
1860 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1861
1862 let result = provider
1863 .add_labels(18, &["type:enhancement".to_string()])
1864 .await;
1865
1866 assert!(result.is_ok(), "expected Ok, got {result:?}");
1867 }
1868
1869 #[tokio::test]
1870 async fn test_should_propagate_error_when_glab_label_create_fails() {
1871 let runner = SequencedMockCommandRunner::from_results(&[
1872 (false, "failed to update ...: 'ghost' not found"),
1873 (false, "glab: 403 Forbidden"),
1874 ]);
1875 let provider = GitLabIssueProvider::with_runner("o/r", runner);
1876
1877 let result = provider.add_labels(1, &["ghost".to_string()]).await;
1878
1879 assert!(result.is_err());
1880 }
1881
1882 #[tokio::test]
1883 async fn test_should_not_retry_on_non_label_error_glab() {
1884 let runner = SequencedMockCommandRunner::from_results(&[(false, "glab: Not logged in")]);
1885 let provider = GitLabIssueProvider::with_runner("o/r", runner);
1886
1887 let result = provider.add_labels(1, &["bug".to_string()]).await;
1888
1889 assert!(result.is_err());
1890 }
1891
1892 #[tokio::test]
1893 async fn test_should_walk_pages_with_per_page_100_on_glab() {
1894 let runner = MockCommandRunner::success("[]");
1895 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1896 provider
1897 .list(ListIssueArgs::default())
1898 .await
1899 .expect("list should succeed");
1900 let recorded = &runner.recorded_calls()[0].1;
1901 assert!(
1902 recorded
1903 .windows(2)
1904 .any(|w| w[0] == "--per-page" && w[1] == "100"),
1905 "glab 的 --per-page 受 API 限制上限 100,必须按页大小而非总数传,实际 argv: \
1906 {recorded:?}"
1907 );
1908 assert!(
1909 recorded.windows(2).any(|w| w[0] == "--page" && w[1] == "1"),
1910 "必须显式指定页号,实际 argv: {recorded:?}"
1911 );
1912 assert_eq!(
1913 runner.recorded_calls().len(),
1914 1,
1915 "首页为空(短于 per_page)即已取尽,不得请求第 2 页"
1916 );
1917 }
1918
1919 #[tokio::test]
1920 async fn test_should_forward_label_filter_to_glab() {
1921 let runner = MockCommandRunner::success("[]");
1922 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1923 let args = ListIssueArgs {
1924 labels: vec!["bug".to_string()],
1925 ..ListIssueArgs::default()
1926 };
1927 provider.list(args).await.expect("list should succeed");
1928 let recorded = &runner.recorded_calls()[0].1;
1929 assert!(
1930 recorded
1931 .windows(2)
1932 .any(|w| w[0] == "--label" && w[1] == "bug"),
1933 "--label 过滤此前被静默丢弃,必须真正传给 glab,实际 argv: {recorded:?}"
1934 );
1935 }
1936
1937 const MILESTONE_LIST_JSON: &str = r#"[
1942 {"id": 30, "iid": 3, "title": "v2.0", "state": "active"}
1943 ]"#;
1944
1945 #[tokio::test]
1946 async fn test_should_wire_resolved_milestone_title_into_issue_create() {
1947 let runner = SequencedMockCommandRunner::from_results(&[
1953 (true, MILESTONE_LIST_JSON),
1954 (true, "http://192.168.230.23/owner/repo/-/issues/42"),
1955 (
1956 true,
1957 r#"{"iid":42,"title":"New feature","description":"Description","state":"opened","labels":[],"milestone":{"id":30,"iid":3,"title":"v2.0","state":"active"},"web_url":"http://192.168.230.23/owner/repo/-/issues/42"}"#,
1958 ),
1959 ]);
1960 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1961
1962 let mut args = sample_create_args();
1963 args.milestone = Some("3".to_string()); let issue = provider.create(args).await.expect("create should succeed");
1966 assert_eq!(
1967 issue.milestone,
1968 Some(gitflow_core::types::MilestoneRef {
1969 number: 3,
1970 title: "v2.0".into()
1971 })
1972 );
1973
1974 let calls = runner.recorded_calls();
1975 assert_eq!(calls.len(), 3, "expected exactly 3 glab invocations");
1976 assert!(
1977 calls[0].1.first().map(String::as_str) == Some("milestone"),
1978 "first call must resolve the milestone via `glab milestone list`, got: {:?}",
1979 calls[0].1
1980 );
1981 let create_call = &calls[1].1;
1982 assert!(
1983 create_call
1984 .windows(2)
1985 .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
1986 "issue create argv must carry the resolved milestone title, got: {create_call:?}"
1987 );
1988 }
1989
1990 #[tokio::test]
1991 async fn test_should_propagate_error_when_milestone_identifier_not_found_on_create() {
1992 let runner = SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON)]);
1995 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1996
1997 let mut args = sample_create_args();
1998 args.milestone = Some("does-not-exist".to_string());
1999
2000 let result = provider.create(args).await;
2001 assert!(result.is_err());
2002 }
2003
2004 #[tokio::test]
2005 async fn test_should_wire_resolved_milestone_title_into_issue_edit() {
2006 let runner = SequencedMockCommandRunner::from_results(&[
2011 (true, MILESTONE_LIST_JSON),
2012 (true, ""),
2013 (
2014 true,
2015 r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[],"milestone":{"id":30,"iid":3,"title":"v2.0","state":"active"},"web_url":"http://192.168.230.23/owner/repo/-/issues/42"}"#,
2016 ),
2017 ]);
2018 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
2019
2020 let issue = provider
2021 .edit(
2022 42,
2023 gitflow_core::issue::EditIssueArgs {
2024 title: None,
2025 body: None,
2026 milestone: Some(Some("v2.0".to_string())),
2027 },
2028 )
2029 .await
2030 .expect("edit should succeed");
2031 assert_eq!(issue.milestone.map(|m| m.title), Some("v2.0".to_string()));
2032
2033 let calls = runner.recorded_calls();
2034 let edit_call = &calls[1].1;
2035 assert!(
2036 edit_call
2037 .windows(2)
2038 .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
2039 "issue edit argv must carry the resolved milestone title, got: {edit_call:?}"
2040 );
2041 }
2042
2043 #[tokio::test]
2044 async fn test_should_send_empty_milestone_flag_to_unassign_without_resolving() {
2045 let runner = MockCommandRunner::success("");
2051 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
2052
2053 let _ = provider
2054 .edit(
2055 7,
2056 gitflow_core::issue::EditIssueArgs {
2057 title: None,
2058 body: None,
2059 milestone: Some(None),
2060 },
2061 )
2062 .await;
2063
2064 let calls = runner.recorded_calls();
2065 assert_eq!(calls.len(), 2, "no milestone resolution call expected");
2068 assert!(
2069 calls[0]
2070 .1
2071 .windows(2)
2072 .any(|w| w[0] == "--milestone" && w[1].is_empty()),
2073 "edit argv must carry --milestone \"\", got: {:?}",
2074 calls[0].1
2075 );
2076 }
2077
2078 #[tokio::test]
2079 async fn test_should_wire_resolved_milestone_title_into_issue_list_filter() {
2080 let runner =
2084 SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON), (true, "[]")]);
2085 let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
2086
2087 let args = ListIssueArgs {
2088 milestone: Some("v2.0".to_string()),
2089 ..ListIssueArgs::default()
2090 };
2091 provider.list(args).await.expect("list should succeed");
2092
2093 let calls = runner.recorded_calls();
2094 let list_call = &calls[1].1;
2095 assert!(
2096 list_call
2097 .windows(2)
2098 .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
2099 "issue list argv must carry the resolved milestone title, got: {list_call:?}"
2100 );
2101 }
2102
2103 #[tokio::test]
2112 async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_create() {
2113 let runner = SequencedMockCommandRunner::from_results(&[
2114 (true, MILESTONE_LIST_JSON),
2115 (true, "http://192.168.230.23/owner/repo/-/issues/42"),
2116 (
2117 true,
2118 r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[]}"#,
2119 ),
2120 ]);
2121 let provider = GitLabIssueProvider::with_runner_and_repo_target(
2122 "owner/repo",
2123 "https://192.168.230.23/iproost/proxy/api-src.git",
2124 runner.clone(),
2125 );
2126
2127 let mut args = sample_create_args();
2128 args.milestone = Some("3".to_string());
2129 provider.create(args).await.expect("create should succeed");
2130
2131 let resolve_call = &runner.recorded_calls()[0].1;
2132 assert!(
2133 resolve_call.iter().any(|a| a == "owner/repo"),
2134 "milestone resolution must target the bare repo, got: {resolve_call:?}"
2135 );
2136 assert!(
2137 !resolve_call
2138 .iter()
2139 .any(|a| a.contains("192.168.230.23/iproost/proxy")),
2140 "milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
2141 );
2142 }
2143
2144 #[tokio::test]
2145 async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_edit() {
2146 let runner = SequencedMockCommandRunner::from_results(&[
2147 (true, MILESTONE_LIST_JSON),
2148 (true, ""),
2149 (
2150 true,
2151 r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[]}"#,
2152 ),
2153 ]);
2154 let provider = GitLabIssueProvider::with_runner_and_repo_target(
2155 "owner/repo",
2156 "https://192.168.230.23/iproost/proxy/api-src.git",
2157 runner.clone(),
2158 );
2159
2160 provider
2161 .edit(
2162 42,
2163 gitflow_core::issue::EditIssueArgs {
2164 title: None,
2165 body: None,
2166 milestone: Some(Some("v2.0".to_string())),
2167 },
2168 )
2169 .await
2170 .expect("edit should succeed");
2171
2172 let resolve_call = &runner.recorded_calls()[0].1;
2173 assert!(
2174 resolve_call.iter().any(|a| a == "owner/repo"),
2175 "milestone resolution must target the bare repo, got: {resolve_call:?}"
2176 );
2177 assert!(
2178 !resolve_call
2179 .iter()
2180 .any(|a| a.contains("192.168.230.23/iproost/proxy")),
2181 "milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
2182 );
2183 }
2184
2185 #[tokio::test]
2186 async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_list() {
2187 let runner =
2188 SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON), (true, "[]")]);
2189 let provider = GitLabIssueProvider::with_runner_and_repo_target(
2190 "owner/repo",
2191 "https://192.168.230.23/iproost/proxy/api-src.git",
2192 runner.clone(),
2193 );
2194
2195 let args = ListIssueArgs {
2196 milestone: Some("v2.0".to_string()),
2197 ..ListIssueArgs::default()
2198 };
2199 provider.list(args).await.expect("list should succeed");
2200
2201 let resolve_call = &runner.recorded_calls()[0].1;
2202 assert!(
2203 resolve_call.iter().any(|a| a == "owner/repo"),
2204 "milestone resolution must target the bare repo, got: {resolve_call:?}"
2205 );
2206 assert!(
2207 !resolve_call
2208 .iter()
2209 .any(|a| a.contains("192.168.230.23/iproost/proxy")),
2210 "milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
2211 );
2212 }
2213}
2214
2215#[cfg(test)]
2216mod contract_tests {
2217 use super::*;
2218 use crate::runner::MockCommandRunner;
2219
2220 #[tokio::test]
2224 async fn test_contract_issue_list_gitlab_v1() {
2225 let fixture = include_str!("../tests/fixtures/issue_list_gitlab_v1.json");
2226 let runner = MockCommandRunner::success(fixture);
2227 let provider = GitLabIssueProvider::with_runner("group/project", runner);
2228
2229 let issues = provider
2230 .list(ListIssueArgs::default())
2231 .await
2232 .expect("contract fixture must parse");
2233 let issues = issues.items;
2234
2235 assert_eq!(issues.len(), 1);
2236 let issue = &issues[0];
2237 assert_eq!(issue.number, 10);
2238 assert!(!issue.title.is_empty());
2239 assert_eq!(issue.state, gitflow_core::types::State::Open);
2240 }
2241}