1use async_trait::async_trait;
10use gitflow_cli_adapter_utils::{EnvSource, RealEnv};
11use gitflow_core::{
12 CoreError, Result,
13 auth::{AuthProvider, AuthStatus, HostAuthStatus},
14};
15use tracing::debug;
16
17use crate::{
18 error::parse_glab_error,
19 runner::{CommandRunner, RealCommandRunner},
20};
21
22#[derive(Debug, Clone)]
37pub struct GitLabAuthProvider<R: CommandRunner = RealCommandRunner, E: EnvSource = RealEnv> {
38 runner: R,
40 env: E,
42}
43
44impl GitLabAuthProvider<RealCommandRunner, RealEnv> {
45 #[must_use]
47 pub fn new() -> Self {
48 Self {
49 runner: RealCommandRunner,
50 env: RealEnv,
51 }
52 }
53
54 #[must_use]
59 pub fn with_session(_session: &gitflow_core::Session) -> Self {
60 Self {
61 runner: RealCommandRunner,
62 env: RealEnv,
63 }
64 }
65}
66
67impl<R: CommandRunner> GitLabAuthProvider<R, RealEnv> {
68 #[must_use]
72 pub fn with_runner(runner: R) -> Self {
73 Self {
74 runner,
75 env: RealEnv,
76 }
77 }
78}
79
80impl<R: CommandRunner, E: EnvSource> GitLabAuthProvider<R, E> {
81 #[must_use]
86 pub fn with_runner_and_env(runner: R, env: E) -> Self {
87 Self { runner, env }
88 }
89}
90
91impl Default for GitLabAuthProvider<RealCommandRunner, RealEnv> {
92 fn default() -> Self {
93 Self::new()
94 }
95}
96
97#[async_trait]
98impl<R: CommandRunner + 'static, E: EnvSource + 'static> AuthProvider for GitLabAuthProvider<R, E> {
99 async fn login(&self, token: Option<&str>) -> Result<()> {
100 debug!("spawning `glab auth login`");
101
102 let output = if let Some(token) = token {
105 self.runner
106 .run_with_stdin("glab", &["auth", "login", "--stdin"], token.as_bytes())
107 .await
108 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth login: {e}")))?
109 } else {
110 self.runner
111 .run("glab", &["auth", "login"])
112 .await
113 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth login: {e}")))?
114 };
115
116 if !output.status.success() {
117 return Err(parse_glab_error(&output.stderr).into());
118 }
119
120 Ok(())
121 }
122
123 async fn logout(&self) -> Result<()> {
124 debug!("spawning `glab auth logout`");
125
126 let output = self
127 .runner
128 .run("glab", &["auth", "logout"])
129 .await
130 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth logout: {e}")))?;
131
132 if !output.status.success() {
133 return Err(parse_glab_error(&output.stderr).into());
134 }
135
136 Ok(())
137 }
138
139 async fn status(&self) -> Result<AuthStatus> {
140 debug!("spawning `glab auth status`");
141
142 let output = self
143 .runner
144 .run("glab", &["auth", "status"])
145 .await
146 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth status: {e}")))?;
147
148 let stdout = String::from_utf8_lossy(&output.stdout);
149 let stderr = String::from_utf8_lossy(&output.stderr);
150 let combined = format!("{stdout}{stderr}");
151
152 let hosts = parse_hosts_from_status(&combined);
153
154 if !hosts.is_empty() {
155 let logged_in = hosts.iter().any(|h| h.logged_in);
156 let user = hosts
157 .iter()
158 .find(|h| h.logged_in)
159 .and_then(|h| h.user.clone());
160
161 return Ok(AuthStatus {
162 logged_in,
163 user,
164 scopes: vec![],
165 hosts,
166 });
167 }
168
169 if !output.status.success() {
170 let text = combined.to_lowercase();
171 if text.contains("not logged in")
172 || text.contains("no active account")
173 || text.contains("not authenticated")
174 {
175 return Ok(AuthStatus {
176 logged_in: false,
177 user: None,
178 scopes: vec![],
179 hosts: vec![],
180 });
181 }
182
183 return Err(parse_glab_error(&output.stderr).into());
184 }
185
186 Ok(AuthStatus {
187 logged_in: false,
188 user: None,
189 scopes: vec![],
190 hosts: vec![],
191 })
192 }
193
194 async fn token(&self) -> Result<String> {
195 if let Some(tok) = self.env.var("GL_TOKEN") {
197 return Ok(tok);
198 }
199
200 debug!("spawning `glab auth status --show-token`");
201
202 let host = self.env.var("GITLAB_HOST");
203 let mut args: Vec<&str> = vec!["auth", "status", "--show-token"];
204 if let Some(ref h) = host {
205 args.push("--hostname");
206 args.push(h);
207 }
208
209 let output =
210 self.runner.run("glab", &args).await.map_err(|e| {
211 CoreError::Platform(format!("Failed to spawn glab auth status: {e}"))
212 })?;
213
214 if !output.status.success() {
215 return Err(parse_glab_error(&output.stderr).into());
216 }
217
218 let stdout = String::from_utf8_lossy(&output.stdout);
219 let stderr = String::from_utf8_lossy(&output.stderr);
222 let combined = format!("{stdout}{stderr}");
223 combined
224 .lines()
225 .find_map(|line| {
226 if line.contains("Token found") {
227 line.rsplit_once(": ").map(|(_, t)| t.trim().to_string())
228 } else {
229 None
230 }
231 })
232 .filter(|t| !t.is_empty())
233 .ok_or_else(|| {
234 CoreError::Platform("No GitLab token found (run `glab auth login`)".into())
235 })
236 }
237}
238
239#[allow(clippy::disallowed_types, reason = "AuthChecker is synchronous")]
241impl<R: CommandRunner, E: EnvSource> gitflow_core::AuthChecker for GitLabAuthProvider<R, E> {
242 fn is_authenticated(&self) -> bool {
243 if self.env.var("GL_TOKEN").is_some() {
244 return true;
245 }
246
247 let output = std::process::Command::new("glab")
248 .args(["auth", "status"])
249 .output();
250
251 matches!(output, Ok(out) if out.status.success())
252 }
253
254 fn check_status(&self) -> gitflow_core::AuthCheckResult {
255 if self.env.var("GL_TOKEN").is_some() {
257 return gitflow_core::AuthCheckResult {
258 authenticated: true,
259 user: None,
260 reason: None,
261 hint: None,
262 };
263 }
264
265 let output = match std::process::Command::new("glab")
267 .args(["auth", "status"])
268 .output()
269 {
270 Ok(out) => out,
271 Err(e) => {
272 return gitflow_core::AuthCheckResult {
273 authenticated: false,
274 user: None,
275 reason: Some(format!("Failed to execute glab: {e}")),
276 hint: Some("Install GitLab CLI: brew install glab".into()),
277 };
278 }
279 };
280
281 if output.status.success() {
283 let stdout = String::from_utf8_lossy(&output.stdout);
284 let user = parse_user_from_status(&stdout);
285
286 gitflow_core::AuthCheckResult {
287 authenticated: true,
288 user,
289 reason: None,
290 hint: None,
291 }
292 } else {
293 let stderr = String::from_utf8_lossy(&output.stderr);
294
295 gitflow_core::AuthCheckResult {
296 authenticated: false,
297 user: None,
298 reason: Some(stderr.to_string()),
299 hint: Some("Run `glab auth login` to authenticate".into()),
300 }
301 }
302 }
303}
304
305fn parse_hosts_from_status(output: &str) -> Vec<HostAuthStatus> {
313 let mut hosts = Vec::new();
314 let mut current: Option<HostAuthStatus> = None;
315
316 for line in output.lines() {
317 let is_header = !line.starts_with(' ') && !line.starts_with('\t');
318 let trimmed = line.trim();
319
320 if is_header && !trimmed.is_empty() && !trimmed.contains(' ') && trimmed.contains('.') {
321 if let Some(host) = current.take() {
322 hosts.push(host);
323 }
324 current = Some(HostAuthStatus {
325 host: trimmed.to_string(),
326 logged_in: false,
327 user: None,
328 });
329 continue;
330 }
331
332 if let Some(ref mut host) = current
333 && trimmed.contains("Logged in to")
334 {
335 host.logged_in = true;
336 host.user = parse_user_from_status(trimmed);
337 }
338 }
339
340 if let Some(host) = current.take() {
341 hosts.push(host);
342 }
343
344 hosts
345}
346
347fn parse_user_from_status(output: &str) -> Option<String> {
348 for line in output.lines() {
349 if let Some(pos) = line.find(" as ") {
350 let after_as = &line[pos + 4..];
351 if let Some(end) = after_as.find(' ') {
352 let user = &after_as[..end];
353 if !user.is_empty() {
354 return Some(user.to_string());
355 }
356 } else if !after_as.is_empty() {
357 return Some(after_as.trim().to_string());
358 }
359 }
360 }
361 None
362}
363
364#[cfg(test)]
365mod tests {
366 use gitflow_cli_adapter_utils::MockEnv;
367
368 use super::*;
369 use crate::runner::MockCommandRunner;
370
371 fn mock_provider(runner: MockCommandRunner) -> GitLabAuthProvider<MockCommandRunner, MockEnv> {
374 GitLabAuthProvider::with_runner_and_env(runner, MockEnv::empty())
375 }
376
377 #[tokio::test]
378 async fn test_should_short_circuit_token_when_env_var_present() {
379 let runner = MockCommandRunner::success(" ✓ Token found in keyring: glpat-from-cli\n");
381 let provider = GitLabAuthProvider::with_runner_and_env(
382 runner.clone(),
383 MockEnv::with("GL_TOKEN", "glpat-from-env"),
384 );
385
386 let token = provider.token().await.expect("should get token");
387
388 assert_eq!(token, "glpat-from-env");
389 assert!(
390 runner.recorded_calls().is_empty(),
391 "env short-circuit must not spawn glab"
392 );
393 }
394
395 #[tokio::test]
396 async fn test_should_append_hostname_arg_when_gitlab_host_present() {
397 let stdout = " ✓ Token found in operating system keyring: glpat-abcdef\n";
399 let runner = MockCommandRunner::success(stdout);
400 let provider = GitLabAuthProvider::with_runner_and_env(
401 runner.clone(),
402 MockEnv::with("GITLAB_HOST", "gitlab.example.com"),
403 );
404
405 provider.token().await.expect("should get token");
406
407 assert_eq!(
408 runner.recorded_calls()[0].1,
409 vec![
410 "auth",
411 "status",
412 "--show-token",
413 "--hostname",
414 "gitlab.example.com"
415 ]
416 .into_iter()
417 .map(String::from)
418 .collect::<Vec<_>>()
419 );
420 }
421
422 #[test]
423 fn test_should_construct_gitlab_auth_provider() {
424 let provider = GitLabAuthProvider::new();
425 let debug = format!("{provider:?}");
426 assert!(debug.contains("GitLabAuthProvider"));
427 }
428
429 #[test]
430 fn test_should_default_gitlab_auth_provider() {
431 let provider = GitLabAuthProvider::default();
432 let _ = format!("{provider:?}");
433 }
434
435 #[test]
436 fn test_should_clone_gitlab_auth_provider() {
437 let original = GitLabAuthProvider::new();
438 let cloned = original.clone();
439 let _ = format!("{cloned:?}");
440 }
441
442 #[test]
443 fn test_should_parse_user_from_status_output() {
444 let status = r"gitlab.com
445 ✓ Logged in to gitlab.com as root (keyring)
446 ✓ Git operations for gitlab.com configured to use ssh protocol.
447";
448 assert_eq!(parse_user_from_status(status), Some("root".to_string()));
449 }
450
451 #[test]
452 fn test_should_parse_user_from_status_with_different_host() {
453 let status = r"gitlab.com
454 ✓ Logged in to gitlab.com as alice (oauth_token)
455 ✓ Token: glpat-****
456";
457 assert_eq!(parse_user_from_status(status), Some("alice".to_string()));
458 }
459
460 #[test]
461 fn test_should_return_none_when_no_user_in_status() {
462 let status = "No active account found";
463 assert!(parse_user_from_status(status).is_none());
464 }
465
466 #[test]
467 fn test_should_return_none_for_empty_status() {
468 assert!(parse_user_from_status("").is_none());
469 }
470
471 #[test]
472 fn test_should_parse_user_without_suffix() {
473 let status = "Logged in to gitlab.com as bob";
474 assert_eq!(parse_user_from_status(status), Some("bob".to_string()));
475 }
476
477 #[test]
478 fn test_should_report_authenticated_when_token_env_var_present() {
479 use gitflow_core::AuthChecker;
480 let provider = GitLabAuthProvider::with_runner_and_env(
483 MockCommandRunner::success(""),
484 MockEnv::with("GL_TOKEN", "test_token"),
485 );
486 assert!(provider.is_authenticated());
487 }
488
489 #[test]
490 fn test_should_report_authenticated_status_without_reason_when_token_env_var_present() {
491 use gitflow_core::AuthChecker;
492 let provider = GitLabAuthProvider::with_runner_and_env(
495 MockCommandRunner::success(""),
496 MockEnv::with("GL_TOKEN", "test_token"),
497 );
498 let result = provider.check_status();
499 assert!(result.authenticated);
500 assert!(result.reason.is_none());
501 assert!(result.hint.is_none());
502 }
503
504 #[tokio::test]
507 async fn test_should_return_platform_error_when_glab_fails_for_login() {
508 let runner = MockCommandRunner::failure("authentication failed", 256);
509 let provider = GitLabAuthProvider::with_runner(runner);
510
511 let result = provider.login(Some("glpat-token")).await;
512
513 assert!(matches!(
514 result.unwrap_err(),
515 gitflow_core::CoreError::Cli(_)
516 ));
517 }
518
519 #[tokio::test]
520 async fn test_should_return_platform_error_when_glab_fails_for_logout() {
521 let runner = MockCommandRunner::failure("not logged in", 256);
522 let provider = GitLabAuthProvider::with_runner(runner);
523
524 let result = provider.logout().await;
525
526 assert!(matches!(
527 result.unwrap_err(),
528 gitflow_core::CoreError::Cli(_)
529 ));
530 }
531
532 #[tokio::test]
533 async fn test_should_return_logged_out_status_when_glab_reports_not_logged_in() {
534 let runner = MockCommandRunner::failure("not logged in to any GitLab hosts", 256);
535 let provider = GitLabAuthProvider::with_runner(runner);
536
537 let status = provider.status().await.expect("graceful logged-out status");
538
539 assert!(!status.logged_in);
540 assert!(status.user.is_none());
541 }
542
543 #[tokio::test]
544 async fn test_should_return_platform_error_when_status_fails_unexpectedly() {
545 let runner = MockCommandRunner::failure("internal server error", 256);
546 let provider = GitLabAuthProvider::with_runner(runner);
547
548 let result = provider.status().await;
549
550 assert!(matches!(
551 result.unwrap_err(),
552 gitflow_core::CoreError::Cli(_)
553 ));
554 }
555
556 #[tokio::test]
557 async fn test_should_return_platform_error_when_glab_fails_for_token() {
558 let runner = MockCommandRunner::failure("no token found", 256);
559 let provider = mock_provider(runner);
560
561 let result = provider.token().await;
562
563 assert!(matches!(
564 result.unwrap_err(),
565 gitflow_core::CoreError::Cli(_)
566 ));
567 }
568
569 #[tokio::test]
570 async fn test_should_error_when_stdout_has_no_token_line() {
571 let runner = MockCommandRunner::success("");
572 let provider = mock_provider(runner);
573
574 let result = provider.token().await;
575
576 assert!(result.is_err());
577 }
578
579 #[test]
582 fn test_should_construct_with_custom_runner() {
583 let runner = MockCommandRunner::success("");
584 let provider = GitLabAuthProvider::with_runner(runner);
585 let debug = format!("{provider:?}");
586 assert!(debug.contains("GitLabAuthProvider"));
587 }
588
589 #[tokio::test]
590 async fn test_should_login_interactively() {
591 let runner = MockCommandRunner::success("");
592 let provider = GitLabAuthProvider::with_runner(runner);
593
594 let result = provider.login(None).await;
595
596 assert!(result.is_ok());
597 }
598
599 #[tokio::test]
600 async fn test_should_login_with_token_via_stdin() {
601 let runner = MockCommandRunner::success("");
602 let provider = GitLabAuthProvider::with_runner(runner);
603
604 let result = provider.login(Some("glpat-secret-token")).await;
605
606 assert!(result.is_ok());
607 }
608
609 #[tokio::test]
610 async fn test_should_logout_successfully() {
611 let runner = MockCommandRunner::success("");
612 let provider = GitLabAuthProvider::with_runner(runner);
613
614 let result = provider.logout().await;
615
616 assert!(result.is_ok());
617 }
618
619 #[tokio::test]
620 async fn test_should_return_logged_in_status_when_authenticated() {
621 let stdout = r"gitlab.com
622 ✓ Logged in to gitlab.com as testuser (keyring)
623 ✓ Git operations for gitlab.com configured to use ssh protocol.
624";
625 let runner = MockCommandRunner::success(stdout);
626 let provider = GitLabAuthProvider::with_runner(runner);
627
628 let result = provider.status().await;
629
630 assert!(result.is_ok());
631 let status = result.unwrap();
632 assert!(status.logged_in);
633 assert_eq!(status.user, Some("testuser".to_string()));
634 assert!(status.scopes.is_empty());
635 assert_eq!(status.hosts.len(), 1);
636 assert_eq!(status.hosts[0].host, "gitlab.com");
637 }
638
639 #[tokio::test]
640 async fn test_should_report_authenticated_when_any_host_logged_in_in_mixed_status() {
641 let combined = "gitlab.com\n ! No token found (checked config file, keyring, and \
642 environment variables).\n192.168.230.23\n ✓ Logged in to 192.168.230.23 \
643 as baoyuexing (keyring)\n";
644 let runner = MockCommandRunner::failure(combined, 1);
645 let provider = GitLabAuthProvider::with_runner(runner);
646
647 let status = provider
648 .status()
649 .await
650 .expect("should not error on mixed host status");
651
652 assert!(status.logged_in);
653 assert_eq!(status.user, Some("baoyuexing".to_string()));
654 assert_eq!(status.hosts.len(), 2);
655 assert_eq!(status.hosts[0].host, "gitlab.com");
656 assert!(!status.hosts[0].logged_in);
657 assert_eq!(status.hosts[1].host, "192.168.230.23");
658 assert!(status.hosts[1].logged_in);
659 assert_eq!(status.hosts[1].user, Some("baoyuexing".to_string()));
660 }
661
662 #[tokio::test]
663 async fn test_should_not_treat_single_word_error_line_as_host() {
664 let runner = MockCommandRunner::failure("unauthorized", 1);
665 let provider = GitLabAuthProvider::with_runner(runner);
666
667 let result = provider.status().await;
668
669 assert!(
670 result.is_err(),
671 "a bare single-word error line must not be parsed as a fake host (expected Err, got \
672 {result:?})"
673 );
674 }
675
676 #[tokio::test]
677 async fn test_should_return_token_successfully() {
678 let stdout = " ✓ Token found in operating system keyring: glpat-test12345\n";
679 let runner = MockCommandRunner::success(stdout);
680 let provider = mock_provider(runner);
681
682 let result = provider.token().await;
683
684 assert!(result.is_ok());
685 assert_eq!(result.unwrap(), "glpat-test12345");
686 }
687
688 #[tokio::test]
689 async fn test_should_trim_whitespace_from_token() {
690 let stdout = " ✓ Token found in keyring: glpat-test12345 \n\n";
691 let runner = MockCommandRunner::success(stdout);
692 let provider = mock_provider(runner);
693
694 let result = provider.token().await;
695
696 assert!(result.is_ok());
697 assert_eq!(result.unwrap(), "glpat-test12345");
698 }
699
700 #[tokio::test]
701 async fn test_should_extract_token_from_auth_status_show_token() {
702 let stdout = "192.168.230.23\n ✓ Logged in to 192.168.230.23 as baoyuexing (keyring)\n \
703 ✓ Token found in operating system keyring: glpat-abcdef\n";
704 let runner = MockCommandRunner::success(stdout);
705 let provider = mock_provider(runner.clone());
706
707 let token = provider.token().await.expect("should get token");
708
709 assert_eq!(token, "glpat-abcdef");
710 assert_eq!(
711 runner.recorded_calls()[0].1,
712 vec!["auth", "status", "--show-token"]
713 .into_iter()
714 .map(String::from)
715 .collect::<Vec<_>>()
716 );
717 }
718
719 #[tokio::test]
720 async fn test_should_extract_token_from_stderr_like_real_glab() {
721 let stderr = "192.168.230.23\n ✓ Logged in to 192.168.230.23 as baoyuexing (keyring)\n \
725 ✓ Token found in operating system keyring: glpat-abcdef\n";
726 let runner = MockCommandRunner::success_with_stderr("", stderr);
727 let provider = mock_provider(runner);
728
729 let token = provider
730 .token()
731 .await
732 .expect("should get token from stderr");
733
734 assert_eq!(token, "glpat-abcdef");
735 }
736
737 #[tokio::test]
738 async fn test_should_error_when_no_token_found() {
739 let stdout =
740 " ! No token found (checked config file, keyring, and environment variables).\n";
741 let runner = MockCommandRunner::success(stdout);
742 let provider = mock_provider(runner);
743
744 let result = provider.token().await;
745
746 assert!(result.is_err());
747 }
748
749 #[tokio::test]
752 async fn test_should_return_platform_error_when_login_spawn_fails() {
753 let runner = MockCommandRunner::spawn_error();
754 let provider = GitLabAuthProvider::with_runner(runner);
755
756 let result = provider.login(None).await;
757
758 assert!(matches!(
759 result.unwrap_err(),
760 gitflow_core::CoreError::Platform(_)
761 ));
762 }
763
764 #[tokio::test]
765 async fn test_should_return_platform_error_when_login_with_token_spawn_fails() {
766 let runner = MockCommandRunner::spawn_error();
767 let provider = GitLabAuthProvider::with_runner(runner);
768
769 let result = provider.login(Some("glpat-token")).await;
770
771 assert!(matches!(
772 result.unwrap_err(),
773 gitflow_core::CoreError::Platform(_)
774 ));
775 }
776
777 #[tokio::test]
778 async fn test_should_return_platform_error_when_logout_spawn_fails() {
779 let runner = MockCommandRunner::spawn_error();
780 let provider = GitLabAuthProvider::with_runner(runner);
781
782 let result = provider.logout().await;
783
784 assert!(matches!(
785 result.unwrap_err(),
786 gitflow_core::CoreError::Platform(_)
787 ));
788 }
789
790 #[tokio::test]
791 async fn test_should_return_platform_error_when_status_spawn_fails() {
792 let runner = MockCommandRunner::spawn_error();
793 let provider = GitLabAuthProvider::with_runner(runner);
794
795 let result = provider.status().await;
796
797 assert!(matches!(
798 result.unwrap_err(),
799 gitflow_core::CoreError::Platform(_)
800 ));
801 }
802
803 #[tokio::test]
804 async fn test_should_return_platform_error_when_token_spawn_fails() {
805 let runner = MockCommandRunner::spawn_error();
806 let provider = mock_provider(runner);
807
808 let result = provider.token().await;
809
810 assert!(matches!(
811 result.unwrap_err(),
812 gitflow_core::CoreError::Platform(_)
813 ));
814 }
815}