Skip to main content

gitflow_gitlab/
auth.rs

1//! GitLab 认证提供者实现。
2//!
3//! 通过 `glab auth` CLI 命令实现 [`AuthProvider`] trait,支持登录、
4//! 登出、状态查询及 Token 管理。
5//! 异步方法通过 [`CommandRunner`] 抽象调用 `glab`,测试可注入自定义 runner
6//! 以模拟成功或失败场景。
7
8use 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/// GitLab 认证提供者,通过 `glab` CLI 操作认证。
21///
22/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
23/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
24///
25/// # Examples
26///
27/// ```no_run
28/// use gitflow_gitlab::GitLabAuthProvider;
29///
30/// let provider = GitLabAuthProvider::new();
31/// ```
32#[derive(Debug, Clone)]
33pub struct GitLabAuthProvider<R: CommandRunner = RealCommandRunner> {
34    /// 用于执行 `glab` CLI 命令的 runner。
35    runner: R,
36}
37
38impl GitLabAuthProvider<RealCommandRunner> {
39    /// 创建新的 GitLab 认证提供者,使用真实的进程执行器。
40    #[must_use]
41    pub fn new() -> Self {
42        Self {
43            runner: RealCommandRunner,
44        }
45    }
46}
47
48impl<R: CommandRunner> GitLabAuthProvider<R> {
49    /// 使用自定义 [`CommandRunner`] 创建提供者。
50    ///
51    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
52    #[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        // If token is provided, pass it via stdin to avoid exposing it in
70        // process arguments (visible to other users via `ps`).
71        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        // glab auth status outputs to stderr, not stdout
135        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// AuthChecker 是同步 trait,必须使用 std::process::Command
164#[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        // 1. 检查环境变量
180        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        // 2. 执行 glab auth status
190        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        // 3. 解析结果
206        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    // --- Failure-path tests using an injected MockCommandRunner ---
327
328    #[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    // --- Success-path tests using an injected MockCommandRunner ---
405
406    #[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    // --- Spawn-error tests using an injected MockCommandRunner ---
485
486    #[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}