1use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14 CoreError, Result,
15 issue::{CreateIssueArgs, IssueData, IssueProvider, ListIssueArgs},
16 types::{CommentData, Label, State, UserSummary},
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22 error::parse_glab_error,
23 runner::{CommandRunner, RealCommandRunner},
24};
25
26#[derive(Debug, Clone)]
42pub struct GitLabIssueProvider<R: CommandRunner = RealCommandRunner> {
43 repo: String,
45 runner: R,
47}
48
49impl GitLabIssueProvider<RealCommandRunner> {
50 #[must_use]
54 pub fn new(repo: impl Into<String>) -> Self {
55 Self {
56 repo: repo.into(),
57 runner: RealCommandRunner,
58 }
59 }
60}
61
62impl<R: CommandRunner> GitLabIssueProvider<R> {
63 #[must_use]
68 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
69 Self {
70 repo: repo.into(),
71 runner,
72 }
73 }
74
75 async fn ensure_label_exists(&self, name: &str) -> Result<()> {
83 debug!(repo = %self.repo, name, "auto-creating missing label via `glab label create`");
84
85 let output = self
86 .runner
87 .run(
88 "glab",
89 &[
90 "label", "create", "--name", name, "--color", "ededed", "--repo", &self.repo,
91 ],
92 )
93 .await
94 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label create: {e}")))?;
95
96 if !output.status.success() {
97 let glab_err = parse_glab_error(&output.stderr);
98 tracing::debug!(error = %glab_err, "Failed to auto-create label");
99 return Err(CoreError::Platform(format!(
100 "Failed to auto-create label '{name}': {}",
101 glab_err.user_message
102 )));
103 }
104
105 Ok(())
106 }
107}
108
109#[derive(Debug, Clone, Deserialize)]
113struct ApiUser {
114 username: String,
115 #[serde(default)]
116 id: u64,
117}
118
119impl From<&ApiUser> for UserSummary {
120 fn from(u: &ApiUser) -> Self {
121 Self {
122 login: u.username.clone(),
123 id: u.id.to_string(),
124 }
125 }
126}
127
128#[derive(Debug, Clone, Deserialize)]
130struct IssueApiResponse {
131 iid: u64,
132 title: String,
133 #[serde(default)]
134 description: Option<String>,
135 state: String,
136 #[serde(default)]
137 labels: Vec<String>,
138 #[serde(default)]
139 author: Option<ApiUser>,
140 #[serde(default)]
141 assignees: Vec<ApiUser>,
142 #[serde(default)]
143 created_at: Option<DateTime<Utc>>,
144 #[serde(default)]
145 updated_at: Option<DateTime<Utc>>,
146 #[serde(default)]
147 web_url: Option<String>,
148}
149
150impl From<IssueApiResponse> for IssueData {
151 fn from(api: IssueApiResponse) -> Self {
152 let now = Utc::now();
153 let labels: Vec<Label> = api
154 .labels
155 .into_iter()
156 .map(|name| Label {
157 name,
158 color: None,
159 description: None,
160 })
161 .collect();
162 let author = api.author.as_ref().map_or_else(
163 || UserSummary {
164 login: "unknown".into(),
165 id: "0".to_string(),
166 },
167 UserSummary::from,
168 );
169
170 Self {
171 number: api.iid,
172 title: api.title,
173 body: api.description,
174 state: if api.state == "closed" {
175 State::Closed
176 } else {
177 State::Open
178 },
179 labels,
180 author,
181 assignees: api.assignees.iter().map(UserSummary::from).collect(),
182 created_at: api.created_at.unwrap_or(now),
183 updated_at: api.updated_at.unwrap_or(now),
184 url: api.web_url.unwrap_or_default(),
185 }
186 }
187}
188
189#[derive(Debug, Clone, Deserialize)]
191struct CommentApiResponse {
192 id: u64,
193 #[serde(default)]
194 body: String,
195 #[serde(default)]
196 author: Option<ApiUser>,
197 #[serde(default)]
198 created_at: Option<DateTime<Utc>>,
199}
200
201impl From<CommentApiResponse> for CommentData {
202 fn from(api: CommentApiResponse) -> Self {
203 let author = api.author.as_ref().map_or_else(
204 || UserSummary {
205 login: "unknown".into(),
206 id: "0".to_string(),
207 },
208 UserSummary::from,
209 );
210 Self {
211 id: api.id,
212 body: api.body,
213 author,
214 created_at: api.created_at.unwrap_or_else(Utc::now),
215 }
216 }
217}
218
219#[async_trait]
222impl<R: CommandRunner + 'static> IssueProvider for GitLabIssueProvider<R> {
223 async fn create(&self, args: CreateIssueArgs) -> Result<IssueData> {
224 let labels_joined = args.labels.join(",");
225 let assignees_joined = args.assignees.join(",");
226
227 let mut cmd_args: Vec<&str> = vec![
228 "issue",
229 "create",
230 "--repo",
231 &self.repo,
232 "--title",
233 &args.title,
234 ];
235
236 if let Some(body) = &args.body {
237 cmd_args.push("--description");
238 cmd_args.push(body);
239 }
240
241 if !args.labels.is_empty() {
242 cmd_args.push("--label");
243 cmd_args.push(&labels_joined);
244 }
245
246 if !args.assignees.is_empty() {
247 cmd_args.push("--assignee");
248 cmd_args.push(&assignees_joined);
249 }
250
251 debug!(repo = %self.repo, title = %args.title, "spawning `glab issue create`");
252
253 let output = self
254 .runner
255 .run("glab", &cmd_args)
256 .await
257 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
258
259 if !output.status.success() {
260 let missing = extract_missing_labels_from_error(&output.stderr);
263 if !missing.is_empty() {
264 debug!(
265 repo = %self.repo,
266 missing_count = missing.len(),
267 "auto-creating missing label(s) before retrying issue create"
268 );
269 for label in &missing {
270 self.ensure_label_exists(label).await?;
271 }
272
273 let retry_output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
274 CoreError::Platform(format!("Failed to spawn glab on retry: {e}"))
275 })?;
276
277 if !retry_output.status.success() {
278 return Err(parse_glab_error(&retry_output.stderr).into());
279 }
280
281 let stdout = String::from_utf8_lossy(&retry_output.stdout);
282 let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
283 CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
284 })?;
285 return self.view(issue_iid).await;
286 }
287
288 return Err(parse_glab_error(&output.stderr).into());
289 }
290
291 let stdout = String::from_utf8_lossy(&output.stdout);
293 let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
294 CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
295 })?;
296
297 self.view(issue_iid).await
299 }
300
301 async fn list(&self, args: ListIssueArgs) -> Result<Vec<IssueData>> {
302 let mut cmd_args: Vec<&str> =
303 vec!["issue", "list", "--repo", &self.repo, "--output", "json"];
304
305 if let Some(state) = &args.state
308 && matches!(state, State::Closed)
309 {
310 cmd_args.push("--closed");
311 }
312
313 if let Some(ref search) = args.search {
314 cmd_args.push("--search");
315 cmd_args.push(search);
316 }
317
318 let limit_str = args.limit.map(|limit| limit.to_string());
319 if let Some(ref limit) = limit_str {
320 cmd_args.push("--per-page");
321 cmd_args.push(limit);
322 }
323
324 debug!(repo = %self.repo, "spawning `glab issue list`");
325
326 let output = self
327 .runner
328 .run("glab", &cmd_args)
329 .await
330 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
331
332 if !output.status.success() {
333 return Err(parse_glab_error(&output.stderr).into());
334 }
335
336 let api_responses: Vec<IssueApiResponse> =
337 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
338
339 Ok(api_responses.into_iter().map(IssueData::from).collect())
340 }
341
342 async fn view(&self, number: u64) -> Result<IssueData> {
343 debug!(repo = %self.repo, number, "spawning `glab issue view`");
344
345 let number_str = number.to_string();
346 let output = self
347 .runner
348 .run(
349 "glab",
350 &[
351 "issue",
352 "view",
353 &number_str,
354 "--repo",
355 &self.repo,
356 "--output",
357 "json",
358 ],
359 )
360 .await
361 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
362
363 if !output.status.success() {
364 return Err(parse_glab_error(&output.stderr).into());
365 }
366
367 let api_response: IssueApiResponse =
368 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
369
370 Ok(api_response.into())
371 }
372
373 async fn close(&self, number: u64) -> Result<IssueData> {
382 debug!(repo = %self.repo, number, "spawning `glab issue close`");
383
384 let number_str = number.to_string();
385 let output = self
386 .runner
387 .run(
388 "glab",
389 &[
390 "issue",
391 "close",
392 &number_str,
393 "--repo",
394 &self.repo,
395 "--output",
396 "json",
397 ],
398 )
399 .await
400 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
401
402 if !output.status.success() {
403 return Err(parse_glab_error(&output.stderr).into());
404 }
405
406 let api_response: IssueApiResponse =
407 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
408
409 Ok(api_response.into())
410 }
411
412 async fn reopen(&self, number: u64) -> Result<IssueData> {
421 debug!(repo = %self.repo, number, "spawning `glab issue reopen`");
422
423 let number_str = number.to_string();
424 let output = self
425 .runner
426 .run(
427 "glab",
428 &[
429 "issue",
430 "reopen",
431 &number_str,
432 "--repo",
433 &self.repo,
434 "--output",
435 "json",
436 ],
437 )
438 .await
439 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
440
441 if !output.status.success() {
442 return Err(parse_glab_error(&output.stderr).into());
443 }
444
445 let api_response: IssueApiResponse =
446 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
447
448 Ok(api_response.into())
449 }
450
451 async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
460 debug!(repo = %self.repo, number, "spawning `glab issue note`");
461
462 let number_str = number.to_string();
463 let output = self
464 .runner
465 .run(
466 "glab",
467 &[
468 "issue",
469 "note",
470 &number_str,
471 "--repo",
472 &self.repo,
473 "--body",
474 body,
475 "--output",
476 "json",
477 ],
478 )
479 .await
480 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
481
482 if !output.status.success() {
483 return Err(parse_glab_error(&output.stderr).into());
484 }
485
486 let api_response: CommentApiResponse =
487 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
488
489 Ok(api_response.into())
490 }
491
492 async fn add_labels(&self, number: u64, labels: &[String]) -> Result<()> {
506 debug!(
507 repo = %self.repo,
508 number,
509 label_count = labels.len(),
510 "spawning `glab issue edit --add-label`"
511 );
512
513 let labels_joined = labels.join(",");
514 let number_str = number.to_string();
515 let cmd_args: Vec<&str> = vec![
516 "issue",
517 "edit",
518 &number_str,
519 "--repo",
520 &self.repo,
521 "--add-label",
522 &labels_joined,
523 ];
524 let output = self
525 .runner
526 .run("glab", &cmd_args)
527 .await
528 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
529
530 if output.status.success() {
531 return Ok(());
532 }
533
534 let missing = extract_missing_labels_from_error(&output.stderr);
537 if missing.is_empty() {
538 return Err(parse_glab_error(&output.stderr).into());
539 }
540
541 debug!(
542 repo = %self.repo,
543 missing_count = missing.len(),
544 "auto-creating missing label(s) before retry"
545 );
546
547 for label in &missing {
548 self.ensure_label_exists(label).await?;
549 }
550
551 let retry_output = self
552 .runner
553 .run("glab", &cmd_args)
554 .await
555 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab on retry: {e}")))?;
556
557 if !retry_output.status.success() {
558 return Err(parse_glab_error(&retry_output.stderr).into());
559 }
560
561 Ok(())
562 }
563
564 async fn remove_label(&self, number: u64, label: &str) -> Result<()> {
572 debug!(repo = %self.repo, number, label, "spawning `glab issue edit --remove-label`");
573
574 let number_str = number.to_string();
575 let output = self
576 .runner
577 .run(
578 "glab",
579 &[
580 "issue",
581 "edit",
582 &number_str,
583 "--repo",
584 &self.repo,
585 "--remove-label",
586 label,
587 ],
588 )
589 .await
590 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
591
592 if !output.status.success() {
593 return Err(parse_glab_error(&output.stderr).into());
594 }
595
596 Ok(())
597 }
598}
599
600fn extract_missing_labels_from_error(stderr: &[u8]) -> Vec<String> {
606 let text = String::from_utf8_lossy(stderr);
607 let mut labels = Vec::new();
608 let mut search_from: usize = 0;
609
610 while let Some(rel_open) = text[search_from..].find('\'') {
612 let open_pos = search_from + rel_open + 1;
613 let Some(rel_close) = text[open_pos..].find('\'') else {
614 break;
615 };
616 let close_pos = open_pos + rel_close;
617 let after_close = &text[close_pos + 1..];
618
619 if after_close.starts_with(" not found") {
620 let label = text[open_pos..close_pos].to_string();
621 if !label.is_empty() {
622 labels.push(label);
623 }
624 }
625 search_from = close_pos + 1;
626 }
627
628 labels
629}
630
631fn parse_issue_iid_from_url(url: &str) -> Option<u64> {
637 url.lines().find_map(|line| {
638 let line = line.trim();
639 if line.contains("/-/issues/") {
640 line.rsplit("/-/issues/")
641 .next()
642 .and_then(|s| s.split('/').next())
643 .and_then(|s| s.parse().ok())
644 } else {
645 None
646 }
647 })
648}
649
650#[cfg(test)]
651mod tests {
652 use super::*;
653 use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
654
655 #[test]
656 fn test_should_construct_gitlab_issue_provider() {
657 let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
658 assert_eq!(provider.repo, "gitlab-org/gitlab");
659 }
660
661 #[test]
662 fn test_should_construct_gitlab_issue_provider_from_string() {
663 let repo = String::from("gitlab-org/gitlab");
664 let provider = GitLabIssueProvider::new(repo);
665 assert_eq!(provider.repo, "gitlab-org/gitlab");
666 }
667
668 #[test]
669 fn test_should_deserialize_issue_api_response() {
670 let json = br#"{
671 "iid": 42,
672 "title": "Fix login bug",
673 "description": "Reproduced on v1.2.3",
674 "state": "opened",
675 "labels": ["bug", "critical"],
676 "author": {"username": "admin", "id": 1},
677 "assignees": [{"username": "alice", "id": 7}],
678 "created_at": "2026-01-15T09:30:00Z",
679 "updated_at": "2026-01-16T11:00:00Z",
680 "web_url": "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
681 }"#;
682
683 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
684 let issue: IssueData = api.into();
685
686 assert_eq!(issue.number, 42);
687 assert_eq!(issue.title, "Fix login bug");
688 assert_eq!(issue.body.as_deref(), Some("Reproduced on v1.2.3"));
689 assert_eq!(issue.state, State::Open);
690 assert_eq!(issue.labels.len(), 2);
691 assert_eq!(issue.labels[0].name, "bug");
692 assert_eq!(issue.author.login, "admin");
693 assert_eq!(issue.assignees.len(), 1);
694 assert_eq!(
695 issue.url,
696 "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
697 );
698 }
699
700 #[test]
701 fn test_should_deserialize_closed_issue_api_response() {
702 let json = br#"{
703 "iid": 10,
704 "title": "Fixed typo",
705 "description": null,
706 "state": "closed",
707 "labels": [],
708 "author": {"username": "dev", "id": 5},
709 "assignees": [],
710 "created_at": "2026-06-01T08:00:00Z",
711 "updated_at": "2026-06-02T12:00:00Z",
712 "web_url": "https://gitlab.com/org/project/-/issues/10"
713 }"#;
714
715 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
716 let issue: IssueData = api.into();
717 assert_eq!(issue.state, State::Closed);
718 }
719
720 #[test]
721 fn test_should_deserialize_comment_api_response() {
722 let json = br#"{
723 "id": 1001,
724 "body": "Thanks for reporting.",
725 "author": {"username": "maintainer", "id": 42},
726 "created_at": "2026-06-15T14:00:00Z"
727 }"#;
728
729 let api: CommentApiResponse =
730 serde_json::from_slice(json).expect("valid CommentApiResponse");
731 let comment: CommentData = api.into();
732 assert_eq!(comment.id, 1001);
733 assert_eq!(comment.body, "Thanks for reporting.");
734 assert_eq!(comment.author.login, "maintainer");
735 }
736
737 #[test]
738 fn test_should_handle_missing_author_with_fallback() {
739 let json = br#"{
740 "iid": 1,
741 "title": "No author",
742 "description": null,
743 "state": "opened",
744 "labels": [],
745 "author": null,
746 "assignees": [],
747 "created_at": null,
748 "updated_at": null,
749 "web_url": null
750 }"#;
751
752 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
753 let issue: IssueData = api.into();
754 assert_eq!(issue.author.login, "unknown");
755 assert_eq!(issue.author.id, "0");
756 }
757
758 #[test]
759 fn test_should_convert_labels_from_strings() {
760 let json = br#"{
761 "iid": 1,
762 "title": "Test",
763 "description": null,
764 "state": "opened",
765 "labels": ["bug", "enhancement", "documentation"],
766 "author": {"username": "admin", "id": 1},
767 "assignees": [],
768 "created_at": "2026-01-01T00:00:00Z",
769 "updated_at": "2026-01-01T00:00:00Z",
770 "web_url": "https://gitlab.com/x/y/-/issues/1"
771 }"#;
772
773 let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
774 let issue: IssueData = api.into();
775 assert_eq!(issue.labels.len(), 3);
776 assert_eq!(issue.labels[0].name, "bug");
777 assert_eq!(issue.labels[1].name, "enhancement");
778 assert!(issue.labels[0].color.is_none());
779 }
780
781 #[test]
782 fn test_should_deserialize_empty_issue_list() {
783 let json = b"[]";
784 let list: Vec<IssueApiResponse> = serde_json::from_slice(json).expect("valid empty list");
785 assert!(list.is_empty());
786 }
787
788 #[test]
789 fn test_should_debug_format_provider() {
790 let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
791 let debug = format!("{provider:?}");
792 assert!(debug.contains("GitLabIssueProvider"));
793 assert!(debug.contains("gitlab-org/gitlab"));
794 }
795
796 #[test]
797 fn test_should_clone_gitlab_issue_provider() {
798 let original = GitLabIssueProvider::new("owner/repo");
799 let cloned = original.clone();
800 assert_eq!(original.repo, cloned.repo);
801 }
802
803 #[test]
804 fn test_should_parse_issue_iid_from_gitlab_url() {
805 assert_eq!(
806 parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/123"),
807 Some(123)
808 );
809 }
810
811 #[test]
812 fn test_should_parse_issue_iid_from_self_hosted_url() {
813 assert_eq!(
814 parse_issue_iid_from_url("https://gitlab.example.com/group/project/-/issues/456"),
815 Some(456)
816 );
817 }
818
819 #[test]
820 fn test_should_parse_issue_iid_from_multiline_output() {
821 let output = "Creating issue...\nhttps://gitlab.com/owner/repo/-/issues/789\nDone.";
822 assert_eq!(parse_issue_iid_from_url(output), Some(789));
823 }
824
825 #[test]
826 fn test_should_return_none_for_invalid_url() {
827 assert_eq!(parse_issue_iid_from_url("not a url"), None);
828 }
829
830 #[test]
831 fn test_should_return_none_for_url_without_iid() {
832 assert_eq!(
833 parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/"),
834 None
835 );
836 }
837
838 #[tokio::test]
841 async fn test_should_return_platform_error_when_glab_fails_for_view() {
842 let runner = MockCommandRunner::failure(r#"{"message": "Issue not found"}"#, 256);
843 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
844
845 let result = provider.view(999).await;
846
847 assert!(result.is_err());
848 assert!(matches!(
849 result.unwrap_err(),
850 gitflow_core::CoreError::Cli(_)
851 ));
852 }
853
854 #[tokio::test]
855 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
856 let runner = MockCommandRunner::success("not valid json");
857 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
858
859 let result = provider.view(1).await;
860
861 assert!(result.is_err());
862 assert!(matches!(
863 result.unwrap_err(),
864 gitflow_core::CoreError::Serialization(_)
865 ));
866 }
867
868 #[tokio::test]
869 async fn test_should_return_platform_error_when_glab_fails_for_list() {
870 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
871 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
872
873 let result = provider.list(ListIssueArgs::default()).await;
874
875 assert!(result.is_err());
876 assert!(matches!(
877 result.unwrap_err(),
878 gitflow_core::CoreError::Cli(_)
879 ));
880 }
881
882 #[tokio::test]
883 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
884 let runner = MockCommandRunner::success("invalid");
885 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
886
887 let result = provider.list(ListIssueArgs::default()).await;
888
889 assert!(result.is_err());
890 assert!(matches!(
891 result.unwrap_err(),
892 gitflow_core::CoreError::Serialization(_)
893 ));
894 }
895
896 fn sample_create_args() -> CreateIssueArgs {
897 CreateIssueArgs {
898 title: "Bug report".to_string(),
899 body: Some("Steps to reproduce".to_string()),
900 labels: vec!["bug".to_string()],
901 assignees: vec!["alice".to_string()],
902 }
903 }
904
905 #[tokio::test]
906 async fn test_should_return_platform_error_when_glab_fails_for_create() {
907 let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
908 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
909
910 let result = provider.create(sample_create_args()).await;
911
912 assert!(result.is_err());
913 assert!(matches!(
914 result.unwrap_err(),
915 gitflow_core::CoreError::Cli(_)
916 ));
917 }
918
919 #[tokio::test]
920 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
921 let runner = MockCommandRunner::success("https://gitlab.com/owner/repo/-/issues/7");
924 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
925
926 let result = provider.create(sample_create_args()).await;
927
928 assert!(result.is_err());
929 assert!(matches!(
930 result.unwrap_err(),
931 gitflow_core::CoreError::Serialization(_)
932 ));
933 }
934
935 #[tokio::test]
936 async fn test_should_return_platform_error_when_glab_fails_for_close() {
937 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
938 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
939
940 let result = provider.close(42).await;
941
942 assert!(result.is_err());
943 assert!(matches!(
944 result.unwrap_err(),
945 gitflow_core::CoreError::Cli(_)
946 ));
947 }
948
949 #[tokio::test]
950 async fn test_should_return_serialization_error_on_invalid_json_for_close() {
951 let runner = MockCommandRunner::success("invalid");
952 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
953
954 let result = provider.close(42).await;
955
956 assert!(result.is_err());
957 assert!(matches!(
958 result.unwrap_err(),
959 gitflow_core::CoreError::Serialization(_)
960 ));
961 }
962
963 #[tokio::test]
964 async fn test_should_return_platform_error_when_glab_fails_for_reopen() {
965 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
966 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
967
968 let result = provider.reopen(42).await;
969
970 assert!(result.is_err());
971 assert!(matches!(
972 result.unwrap_err(),
973 gitflow_core::CoreError::Cli(_)
974 ));
975 }
976
977 #[tokio::test]
978 async fn test_should_return_serialization_error_on_invalid_json_for_reopen() {
979 let runner = MockCommandRunner::success("invalid");
980 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
981
982 let result = provider.reopen(42).await;
983
984 assert!(result.is_err());
985 assert!(matches!(
986 result.unwrap_err(),
987 gitflow_core::CoreError::Serialization(_)
988 ));
989 }
990
991 #[tokio::test]
992 async fn test_should_return_platform_error_when_glab_fails_for_comment() {
993 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
994 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
995
996 let result = provider.comment(42, "a comment").await;
997
998 assert!(result.is_err());
999 assert!(matches!(
1000 result.unwrap_err(),
1001 gitflow_core::CoreError::Cli(_)
1002 ));
1003 }
1004
1005 #[tokio::test]
1006 async fn test_should_return_serialization_error_on_invalid_json_for_comment() {
1007 let runner = MockCommandRunner::success("invalid");
1008 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1009
1010 let result = provider.comment(42, "a comment").await;
1011
1012 assert!(result.is_err());
1013 assert!(matches!(
1014 result.unwrap_err(),
1015 gitflow_core::CoreError::Serialization(_)
1016 ));
1017 }
1018
1019 #[tokio::test]
1020 async fn test_should_return_platform_error_when_glab_fails_for_add_labels() {
1021 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1022 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1023
1024 let result = provider.add_labels(42, &["bug".to_string()]).await;
1025
1026 assert!(result.is_err());
1027 assert!(matches!(
1028 result.unwrap_err(),
1029 gitflow_core::CoreError::Cli(_)
1030 ));
1031 }
1032
1033 #[tokio::test]
1034 async fn test_should_return_platform_error_when_glab_fails_for_remove_label() {
1035 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1036 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1037
1038 let result = provider.remove_label(42, "bug").await;
1039
1040 assert!(result.is_err());
1041 assert!(matches!(
1042 result.unwrap_err(),
1043 gitflow_core::CoreError::Cli(_)
1044 ));
1045 }
1046
1047 #[test]
1050 fn test_should_extract_single_missing_label_from_glab_stderr() {
1051 let stderr = b"failed to update ...: 'type:enhancement' not found";
1052 let missing = extract_missing_labels_from_error(stderr);
1053 assert_eq!(missing, vec!["type:enhancement".to_string()]);
1054 }
1055
1056 #[test]
1057 fn test_should_return_empty_when_no_label_not_found_in_glab_stderr() {
1058 let stderr = b"glab: Not logged in";
1059 let missing = extract_missing_labels_from_error(stderr);
1060 assert!(missing.is_empty());
1061 }
1062
1063 #[tokio::test]
1066 async fn test_should_auto_create_label_and_retry_on_add_labels_glab() {
1067 let runner = SequencedMockCommandRunner::from_results(&[
1068 (false, "failed to update ...: 'type:enhancement' not found"),
1069 (true, "Created label type:enhancement"),
1070 (true, ""),
1071 ]);
1072 let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1073
1074 let result = provider
1075 .add_labels(18, &["type:enhancement".to_string()])
1076 .await;
1077
1078 assert!(result.is_ok(), "expected Ok, got {result:?}");
1079 }
1080
1081 #[tokio::test]
1082 async fn test_should_propagate_error_when_glab_label_create_fails() {
1083 let runner = SequencedMockCommandRunner::from_results(&[
1084 (false, "failed to update ...: 'ghost' not found"),
1085 (false, "glab: 403 Forbidden"),
1086 ]);
1087 let provider = GitLabIssueProvider::with_runner("o/r", runner);
1088
1089 let result = provider.add_labels(1, &["ghost".to_string()]).await;
1090
1091 assert!(result.is_err());
1092 }
1093
1094 #[tokio::test]
1095 async fn test_should_not_retry_on_non_label_error_glab() {
1096 let runner = SequencedMockCommandRunner::from_results(&[(false, "glab: Not logged in")]);
1097 let provider = GitLabIssueProvider::with_runner("o/r", runner);
1098
1099 let result = provider.add_labels(1, &["bug".to_string()]).await;
1100
1101 assert!(result.is_err());
1102 }
1103}
1104
1105#[cfg(test)]
1106mod contract_tests {
1107 use super::*;
1108 use crate::runner::MockCommandRunner;
1109
1110 #[tokio::test]
1114 async fn test_contract_issue_list_gitlab_v1() {
1115 let fixture = include_str!("../tests/fixtures/issue_list_gitlab_v1.json");
1116 let runner = MockCommandRunner::success(fixture);
1117 let provider = GitLabIssueProvider::with_runner("group/project", runner);
1118
1119 let issues = provider
1120 .list(ListIssueArgs::default())
1121 .await
1122 .expect("contract fixture must parse");
1123
1124 assert_eq!(issues.len(), 1);
1125 let issue = &issues[0];
1126 assert_eq!(issue.number, 10);
1127 assert!(!issue.title.is_empty());
1128 assert_eq!(issue.state, gitflow_core::types::State::Open);
1129 }
1130}