Skip to main content

gitflow_gitlab/
auth.rs

1//! GitLab 认证提供者实现。
2//!
3//! 通过 `glab auth` CLI 命令实现 [`AuthProvider`] trait,支持登录、
4//! 登出、状态查询及 Token 管理。
5//! 异步方法通过 [`CommandRunner`] 抽象调用 `glab`,测试可注入自定义 runner
6//! 以模拟成功或失败场景。环境变量读取通过 [`EnvSource`] 参数抽象,生产环境
7//! 默认使用 [`RealEnv`],测试可通过 `with_runner_and_env` 注入自定义实现。
8
9use 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/// GitLab 认证提供者,通过 `glab` CLI 操作认证。
23///
24/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
25/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
26/// 环境变量读取通过 [`EnvSource`] 参数抽象,生产环境默认使用 [`RealEnv`],
27/// 测试可通过 `with_runner_and_env` 注入自定义实现。
28///
29/// # Examples
30///
31/// ```no_run
32/// use gitflow_gitlab::GitLabAuthProvider;
33///
34/// let provider = GitLabAuthProvider::new();
35/// ```
36#[derive(Debug, Clone)]
37pub struct GitLabAuthProvider<R: CommandRunner = RealCommandRunner, E: EnvSource = RealEnv> {
38    /// 用于执行 `glab` CLI 命令的 runner。
39    runner: R,
40    /// 环境变量来源,生产环境为进程环境,测试可注入。
41    env: E,
42}
43
44impl GitLabAuthProvider<RealCommandRunner, RealEnv> {
45    /// 创建新的 GitLab 认证提供者,使用真实的进程执行器与进程环境。
46    #[must_use]
47    pub fn new() -> Self {
48        Self {
49            runner: RealCommandRunner,
50            env: RealEnv,
51        }
52    }
53
54    /// Create a new provider from a shared [`Session`].
55    ///
56    /// `AuthProvider` doesn't use repository context, so session.repo is ignored.
57    /// This enables state reuse across multiple operations in workflow chains.
58    #[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    /// 使用自定义 [`CommandRunner`] 创建提供者,环境变量仍取自进程环境。
69    ///
70    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
71    #[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    /// 同时注入自定义 [`CommandRunner`] 与 [`EnvSource`]。
82    ///
83    /// 测试应优先使用本构造函数:注入的环境变量来源使测试不依赖进程环境,
84    /// 因而既不会被并行测试污染,也不受开发者 shell 中已导出变量的影响。
85    #[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        // If token is provided, pass it via stdin to avoid exposing it in
103        // process arguments (visible to other users via `ps`).
104        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        // 环境变量优先(与 AuthChecker::is_authenticated 一致)
196        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        // glab writes the status block (including the `Token found ...` line) to
220        // stderr even on success; parse both streams like `status()` does.
221        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// AuthChecker 是同步 trait,必须使用 std::process::Command
240#[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        // 1. 检查环境变量
256        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        // 2. 执行 glab auth status
266        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        // 3. 解析结果
282        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
305/// 把 `glab auth status` 的 stdout+stderr 合并文本解析为按 host 分组的状态。
306///
307/// `glab` 对每个已配置 host 输出一个不含空白的裸行作为 host 标识
308/// (如 `gitlab.com`、`192.168.230.23`),紧随其后是若干缩进的状态行。
309/// 要求该裸行包含 `.`(域名或 IPv4 的共同特征),避免把单个单词的通用
310/// 错误信息(如 `unauthorized`)误判成一个"host",从而掩盖真实的平台错误。
311/// 无法识别出任何 host 行时返回空 `Vec`,由调用方回退到旧的整段文本判断。
312fn 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    /// Build a provider whose environment is empty, so tests never depend on
372    /// what the host shell exported.
373    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        // 语义回归护栏:GL_TOKEN 命中时必须优先于 CLI 调用。
380        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        // 语义回归护栏:GITLAB_HOST 命中时追加 --hostname。
398        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        // AuthChecker 同步分支直接调用 std::process::Command,不读取注入的 runner;
481        // env 短路才是本测试确定性的来源。
482        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        // AuthChecker 同步分支直接调用 std::process::Command,不读取注入的 runner;
493        // env 短路才是本测试确定性的来源。
494        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    // --- Failure-path tests using an injected MockCommandRunner ---
505
506    #[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    // --- Success-path tests using an injected MockCommandRunner ---
580
581    #[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        // `glab auth status --show-token` writes the status block (including the
722        // `Token found ...` line) to stderr while exiting 0. Regression test for
723        // the real self-hosted GitLab smoke test (Issue #199).
724        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    // --- Spawn-error tests using an injected MockCommandRunner ---
750
751    #[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}