1use async_trait::async_trait;
9use gitflow_core::{
10 CoreError, Result,
11 auth::{AuthProvider, AuthStatus},
12};
13use tracing::debug;
14
15use crate::{
16 error::parse_glab_error,
17 runner::{CommandRunner, RealCommandRunner},
18};
19
20#[derive(Debug, Clone)]
33pub struct GitLabAuthProvider<R: CommandRunner = RealCommandRunner> {
34 runner: R,
36}
37
38impl GitLabAuthProvider<RealCommandRunner> {
39 #[must_use]
41 pub fn new() -> Self {
42 Self {
43 runner: RealCommandRunner,
44 }
45 }
46}
47
48impl<R: CommandRunner> GitLabAuthProvider<R> {
49 #[must_use]
53 pub fn with_runner(runner: R) -> Self {
54 Self { runner }
55 }
56}
57
58impl Default for GitLabAuthProvider<RealCommandRunner> {
59 fn default() -> Self {
60 Self::new()
61 }
62}
63
64#[async_trait]
65impl<R: CommandRunner + 'static> AuthProvider for GitLabAuthProvider<R> {
66 async fn login(&self, token: Option<&str>) -> Result<()> {
67 debug!("spawning `glab auth login`");
68
69 let output = if let Some(token) = token {
72 self.runner
73 .run_with_stdin("glab", &["auth", "login", "--stdin"], token.as_bytes())
74 .await
75 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth login: {e}")))?
76 } else {
77 self.runner
78 .run("glab", &["auth", "login"])
79 .await
80 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth login: {e}")))?
81 };
82
83 if !output.status.success() {
84 return Err(parse_glab_error(&output.stderr).into());
85 }
86
87 Ok(())
88 }
89
90 async fn logout(&self) -> Result<()> {
91 debug!("spawning `glab auth logout`");
92
93 let output = self
94 .runner
95 .run("glab", &["auth", "logout"])
96 .await
97 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth logout: {e}")))?;
98
99 if !output.status.success() {
100 return Err(parse_glab_error(&output.stderr).into());
101 }
102
103 Ok(())
104 }
105
106 async fn status(&self) -> Result<AuthStatus> {
107 debug!("spawning `glab auth status`");
108
109 let output = self
110 .runner
111 .run("glab", &["auth", "status"])
112 .await
113 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth status: {e}")))?;
114
115 let stdout = String::from_utf8_lossy(&output.stdout);
116 let stderr = String::from_utf8_lossy(&output.stderr);
117
118 if !output.status.success() {
119 let text = format!("{stdout}{stderr}").to_lowercase();
120 if text.contains("not logged in")
121 || text.contains("no active account")
122 || text.contains("not authenticated")
123 {
124 return Ok(AuthStatus {
125 logged_in: false,
126 user: None,
127 scopes: vec![],
128 });
129 }
130
131 return Err(parse_glab_error(&output.stderr).into());
132 }
133
134 let combined = format!("{stdout}{stderr}");
136 let user = parse_user_from_status(&combined);
137
138 Ok(AuthStatus {
139 logged_in: user.is_some(),
140 user,
141 scopes: vec![],
142 })
143 }
144
145 async fn token(&self) -> Result<String> {
146 debug!("spawning `glab auth token`");
147
148 let output = self
149 .runner
150 .run("glab", &["auth", "token"])
151 .await
152 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth token: {e}")))?;
153
154 if !output.status.success() {
155 return Err(parse_glab_error(&output.stderr).into());
156 }
157
158 let token = String::from_utf8_lossy(&output.stdout);
159 Ok(token.trim().to_string())
160 }
161}
162
163#[allow(clippy::disallowed_types, reason = "AuthChecker is synchronous")]
165impl<R: CommandRunner> gitflow_core::AuthChecker for GitLabAuthProvider<R> {
166 fn is_authenticated(&self) -> bool {
167 if std::env::var("GL_TOKEN").is_ok() {
168 return true;
169 }
170
171 let output = std::process::Command::new("glab")
172 .args(["auth", "status"])
173 .output();
174
175 matches!(output, Ok(out) if out.status.success())
176 }
177
178 fn check_status(&self) -> gitflow_core::AuthCheckResult {
179 if std::env::var("GL_TOKEN").is_ok() {
181 return gitflow_core::AuthCheckResult {
182 authenticated: true,
183 user: None,
184 reason: None,
185 hint: None,
186 };
187 }
188
189 let output = match std::process::Command::new("glab")
191 .args(["auth", "status"])
192 .output()
193 {
194 Ok(out) => out,
195 Err(e) => {
196 return gitflow_core::AuthCheckResult {
197 authenticated: false,
198 user: None,
199 reason: Some(format!("Failed to execute glab: {e}")),
200 hint: Some("Install GitLab CLI: brew install glab".into()),
201 };
202 }
203 };
204
205 if output.status.success() {
207 let stdout = String::from_utf8_lossy(&output.stdout);
208 let user = parse_user_from_status(&stdout);
209
210 gitflow_core::AuthCheckResult {
211 authenticated: true,
212 user,
213 reason: None,
214 hint: None,
215 }
216 } else {
217 let stderr = String::from_utf8_lossy(&output.stderr);
218
219 gitflow_core::AuthCheckResult {
220 authenticated: false,
221 user: None,
222 reason: Some(stderr.to_string()),
223 hint: Some("Run `glab auth login` to authenticate".into()),
224 }
225 }
226 }
227}
228
229fn parse_user_from_status(output: &str) -> Option<String> {
230 for line in output.lines() {
231 if let Some(pos) = line.find(" as ") {
232 let after_as = &line[pos + 4..];
233 if let Some(end) = after_as.find(' ') {
234 let user = &after_as[..end];
235 if !user.is_empty() {
236 return Some(user.to_string());
237 }
238 } else if !after_as.is_empty() {
239 return Some(after_as.trim().to_string());
240 }
241 }
242 }
243 None
244}
245
246#[cfg(test)]
247mod tests {
248 use super::*;
249 use crate::runner::MockCommandRunner;
250
251 #[test]
252 fn test_should_construct_gitlab_auth_provider() {
253 let provider = GitLabAuthProvider::new();
254 let debug = format!("{provider:?}");
255 assert!(debug.contains("GitLabAuthProvider"));
256 }
257
258 #[test]
259 fn test_should_default_gitlab_auth_provider() {
260 let provider = GitLabAuthProvider::default();
261 let _ = format!("{provider:?}");
262 }
263
264 #[test]
265 fn test_should_clone_gitlab_auth_provider() {
266 let original = GitLabAuthProvider::new();
267 let cloned = original.clone();
268 let _ = format!("{cloned:?}");
269 }
270
271 #[test]
272 fn test_should_parse_user_from_status_output() {
273 let status = r"gitlab.com
274 ✓ Logged in to gitlab.com as root (keyring)
275 ✓ Git operations for gitlab.com configured to use ssh protocol.
276";
277 assert_eq!(parse_user_from_status(status), Some("root".to_string()));
278 }
279
280 #[test]
281 fn test_should_parse_user_from_status_with_different_host() {
282 let status = r"gitlab.com
283 ✓ Logged in to gitlab.com as alice (oauth_token)
284 ✓ Token: glpat-****
285";
286 assert_eq!(parse_user_from_status(status), Some("alice".to_string()));
287 }
288
289 #[test]
290 fn test_should_return_none_when_no_user_in_status() {
291 let status = "No active account found";
292 assert!(parse_user_from_status(status).is_none());
293 }
294
295 #[test]
296 fn test_should_return_none_for_empty_status() {
297 assert!(parse_user_from_status("").is_none());
298 }
299
300 #[test]
301 fn test_should_parse_user_without_suffix() {
302 let status = "Logged in to gitlab.com as bob";
303 assert_eq!(parse_user_from_status(status), Some("bob".to_string()));
304 }
305
306 #[test]
307 fn test_auth_checker_is_authenticated_with_env_var() {
308 use gitflow_core::AuthChecker;
309 temp_env::with_var("GL_TOKEN", Some("test_token"), || {
310 let provider = GitLabAuthProvider::new();
311 assert!(provider.is_authenticated());
312 });
313 }
314
315 #[test]
316 fn test_auth_checker_check_status_with_env_var() {
317 use gitflow_core::AuthChecker;
318 temp_env::with_var("GL_TOKEN", Some("test_token"), || {
319 let provider = GitLabAuthProvider::new();
320 let result = provider.check_status();
321 assert!(result.authenticated);
322 assert!(result.reason.is_none());
323 });
324 }
325
326 #[tokio::test]
329 async fn test_should_return_platform_error_when_glab_fails_for_login() {
330 let runner = MockCommandRunner::failure("authentication failed", 256);
331 let provider = GitLabAuthProvider::with_runner(runner);
332
333 let result = provider.login(Some("glpat-token")).await;
334
335 assert!(matches!(
336 result.unwrap_err(),
337 gitflow_core::CoreError::Cli(_)
338 ));
339 }
340
341 #[tokio::test]
342 async fn test_should_return_platform_error_when_glab_fails_for_logout() {
343 let runner = MockCommandRunner::failure("not logged in", 256);
344 let provider = GitLabAuthProvider::with_runner(runner);
345
346 let result = provider.logout().await;
347
348 assert!(matches!(
349 result.unwrap_err(),
350 gitflow_core::CoreError::Cli(_)
351 ));
352 }
353
354 #[tokio::test]
355 async fn test_should_return_logged_out_status_when_glab_reports_not_logged_in() {
356 let runner = MockCommandRunner::failure("not logged in to any GitLab hosts", 256);
357 let provider = GitLabAuthProvider::with_runner(runner);
358
359 let status = provider.status().await.expect("graceful logged-out status");
360
361 assert!(!status.logged_in);
362 assert!(status.user.is_none());
363 }
364
365 #[tokio::test]
366 async fn test_should_return_platform_error_when_status_fails_unexpectedly() {
367 let runner = MockCommandRunner::failure("internal server error", 256);
368 let provider = GitLabAuthProvider::with_runner(runner);
369
370 let result = provider.status().await;
371
372 assert!(matches!(
373 result.unwrap_err(),
374 gitflow_core::CoreError::Cli(_)
375 ));
376 }
377
378 #[tokio::test]
379 async fn test_should_return_platform_error_when_glab_fails_for_token() {
380 let runner = MockCommandRunner::failure("no token found", 256);
381 let provider = GitLabAuthProvider::with_runner(runner);
382
383 let result = provider.token().await;
384
385 assert!(matches!(
386 result.unwrap_err(),
387 gitflow_core::CoreError::Cli(_)
388 ));
389 }
390
391 #[tokio::test]
392 async fn test_should_return_empty_token_when_stdout_is_empty() {
393 let runner = MockCommandRunner::success("");
394 let provider = GitLabAuthProvider::with_runner(runner);
395
396 let token = provider
397 .token()
398 .await
399 .expect("empty stdout yields empty token");
400
401 assert!(token.is_empty());
402 }
403
404 #[test]
407 fn test_should_construct_with_custom_runner() {
408 let runner = MockCommandRunner::success("");
409 let provider = GitLabAuthProvider::with_runner(runner);
410 let debug = format!("{provider:?}");
411 assert!(debug.contains("GitLabAuthProvider"));
412 }
413
414 #[tokio::test]
415 async fn test_should_login_interactively() {
416 let runner = MockCommandRunner::success("");
417 let provider = GitLabAuthProvider::with_runner(runner);
418
419 let result = provider.login(None).await;
420
421 assert!(result.is_ok());
422 }
423
424 #[tokio::test]
425 async fn test_should_login_with_token_via_stdin() {
426 let runner = MockCommandRunner::success("");
427 let provider = GitLabAuthProvider::with_runner(runner);
428
429 let result = provider.login(Some("glpat-secret-token")).await;
430
431 assert!(result.is_ok());
432 }
433
434 #[tokio::test]
435 async fn test_should_logout_successfully() {
436 let runner = MockCommandRunner::success("");
437 let provider = GitLabAuthProvider::with_runner(runner);
438
439 let result = provider.logout().await;
440
441 assert!(result.is_ok());
442 }
443
444 #[tokio::test]
445 async fn test_should_return_logged_in_status_when_authenticated() {
446 let stdout = r"gitlab.com
447 ✓ Logged in to gitlab.com as testuser (keyring)
448 ✓ Git operations for gitlab.com configured to use ssh protocol.
449";
450 let runner = MockCommandRunner::success(stdout);
451 let provider = GitLabAuthProvider::with_runner(runner);
452
453 let result = provider.status().await;
454
455 assert!(result.is_ok());
456 let status = result.unwrap();
457 assert!(status.logged_in);
458 assert_eq!(status.user, Some("testuser".to_string()));
459 assert!(status.scopes.is_empty());
460 }
461
462 #[tokio::test]
463 async fn test_should_return_token_successfully() {
464 let runner = MockCommandRunner::success("glpat-test12345\n");
465 let provider = GitLabAuthProvider::with_runner(runner);
466
467 let result = provider.token().await;
468
469 assert!(result.is_ok());
470 assert_eq!(result.unwrap(), "glpat-test12345");
471 }
472
473 #[tokio::test]
474 async fn test_should_trim_whitespace_from_token() {
475 let runner = MockCommandRunner::success(" glpat-test12345 \n\n");
476 let provider = GitLabAuthProvider::with_runner(runner);
477
478 let result = provider.token().await;
479
480 assert!(result.is_ok());
481 assert_eq!(result.unwrap(), "glpat-test12345");
482 }
483
484 #[tokio::test]
487 async fn test_should_return_platform_error_when_login_spawn_fails() {
488 let runner = MockCommandRunner::spawn_error();
489 let provider = GitLabAuthProvider::with_runner(runner);
490
491 let result = provider.login(None).await;
492
493 assert!(matches!(
494 result.unwrap_err(),
495 gitflow_core::CoreError::Platform(_)
496 ));
497 }
498
499 #[tokio::test]
500 async fn test_should_return_platform_error_when_login_with_token_spawn_fails() {
501 let runner = MockCommandRunner::spawn_error();
502 let provider = GitLabAuthProvider::with_runner(runner);
503
504 let result = provider.login(Some("glpat-token")).await;
505
506 assert!(matches!(
507 result.unwrap_err(),
508 gitflow_core::CoreError::Platform(_)
509 ));
510 }
511
512 #[tokio::test]
513 async fn test_should_return_platform_error_when_logout_spawn_fails() {
514 let runner = MockCommandRunner::spawn_error();
515 let provider = GitLabAuthProvider::with_runner(runner);
516
517 let result = provider.logout().await;
518
519 assert!(matches!(
520 result.unwrap_err(),
521 gitflow_core::CoreError::Platform(_)
522 ));
523 }
524
525 #[tokio::test]
526 async fn test_should_return_platform_error_when_status_spawn_fails() {
527 let runner = MockCommandRunner::spawn_error();
528 let provider = GitLabAuthProvider::with_runner(runner);
529
530 let result = provider.status().await;
531
532 assert!(matches!(
533 result.unwrap_err(),
534 gitflow_core::CoreError::Platform(_)
535 ));
536 }
537
538 #[tokio::test]
539 async fn test_should_return_platform_error_when_token_spawn_fails() {
540 let runner = MockCommandRunner::spawn_error();
541 let provider = GitLabAuthProvider::with_runner(runner);
542
543 let result = provider.token().await;
544
545 assert!(matches!(
546 result.unwrap_err(),
547 gitflow_core::CoreError::Platform(_)
548 ));
549 }
550}