use async_trait::async_trait;
use gitflow_core::{
CoreError, Result,
auth::{AuthProvider, AuthStatus},
};
use tracing::debug;
use crate::{
error::parse_glab_error,
runner::{CommandRunner, RealCommandRunner},
};
#[derive(Debug, Clone)]
pub struct GitLabAuthProvider<R: CommandRunner = RealCommandRunner> {
runner: R,
}
impl GitLabAuthProvider<RealCommandRunner> {
#[must_use]
pub fn new() -> Self {
Self {
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitLabAuthProvider<R> {
#[must_use]
pub fn with_runner(runner: R) -> Self {
Self { runner }
}
}
impl Default for GitLabAuthProvider<RealCommandRunner> {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl<R: CommandRunner + 'static> AuthProvider for GitLabAuthProvider<R> {
async fn login(&self, token: Option<&str>) -> Result<()> {
debug!("spawning `glab auth login`");
let output = if let Some(token) = token {
self.runner
.run_with_stdin("glab", &["auth", "login", "--stdin"], token.as_bytes())
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth login: {e}")))?
} else {
self.runner
.run("glab", &["auth", "login"])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth login: {e}")))?
};
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
Ok(())
}
async fn logout(&self) -> Result<()> {
debug!("spawning `glab auth logout`");
let output = self
.runner
.run("glab", &["auth", "logout"])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth logout: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
Ok(())
}
async fn status(&self) -> Result<AuthStatus> {
debug!("spawning `glab auth status`");
let output = self
.runner
.run("glab", &["auth", "status"])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth status: {e}")))?;
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
if !output.status.success() {
let text = format!("{stdout}{stderr}").to_lowercase();
if text.contains("not logged in")
|| text.contains("no active account")
|| text.contains("not authenticated")
{
return Ok(AuthStatus {
logged_in: false,
user: None,
scopes: vec![],
});
}
return Err(parse_glab_error(&output.stderr).into());
}
let combined = format!("{stdout}{stderr}");
let user = parse_user_from_status(&combined);
Ok(AuthStatus {
logged_in: user.is_some(),
user,
scopes: vec![],
})
}
async fn token(&self) -> Result<String> {
debug!("spawning `glab auth token`");
let output = self
.runner
.run("glab", &["auth", "token"])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab auth token: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let token = String::from_utf8_lossy(&output.stdout);
Ok(token.trim().to_string())
}
}
#[allow(clippy::disallowed_types, reason = "AuthChecker is synchronous")]
impl<R: CommandRunner> gitflow_core::AuthChecker for GitLabAuthProvider<R> {
fn is_authenticated(&self) -> bool {
if std::env::var("GL_TOKEN").is_ok() {
return true;
}
let output = std::process::Command::new("glab")
.args(["auth", "status"])
.output();
matches!(output, Ok(out) if out.status.success())
}
fn check_status(&self) -> gitflow_core::AuthCheckResult {
if std::env::var("GL_TOKEN").is_ok() {
return gitflow_core::AuthCheckResult {
authenticated: true,
user: None,
reason: None,
hint: None,
};
}
let output = match std::process::Command::new("glab")
.args(["auth", "status"])
.output()
{
Ok(out) => out,
Err(e) => {
return gitflow_core::AuthCheckResult {
authenticated: false,
user: None,
reason: Some(format!("Failed to execute glab: {e}")),
hint: Some("Install GitLab CLI: brew install glab".into()),
};
}
};
if output.status.success() {
let stdout = String::from_utf8_lossy(&output.stdout);
let user = parse_user_from_status(&stdout);
gitflow_core::AuthCheckResult {
authenticated: true,
user,
reason: None,
hint: None,
}
} else {
let stderr = String::from_utf8_lossy(&output.stderr);
gitflow_core::AuthCheckResult {
authenticated: false,
user: None,
reason: Some(stderr.to_string()),
hint: Some("Run `glab auth login` to authenticate".into()),
}
}
}
}
fn parse_user_from_status(output: &str) -> Option<String> {
for line in output.lines() {
if let Some(pos) = line.find(" as ") {
let after_as = &line[pos + 4..];
if let Some(end) = after_as.find(' ') {
let user = &after_as[..end];
if !user.is_empty() {
return Some(user.to_string());
}
} else if !after_as.is_empty() {
return Some(after_as.trim().to_string());
}
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::MockCommandRunner;
#[test]
fn test_should_construct_gitlab_auth_provider() {
let provider = GitLabAuthProvider::new();
let debug = format!("{provider:?}");
assert!(debug.contains("GitLabAuthProvider"));
}
#[test]
fn test_should_default_gitlab_auth_provider() {
let provider = GitLabAuthProvider::default();
let _ = format!("{provider:?}");
}
#[test]
fn test_should_clone_gitlab_auth_provider() {
let original = GitLabAuthProvider::new();
let cloned = original.clone();
let _ = format!("{cloned:?}");
}
#[test]
fn test_should_parse_user_from_status_output() {
let status = r"gitlab.com
✓ Logged in to gitlab.com as root (keyring)
✓ Git operations for gitlab.com configured to use ssh protocol.
";
assert_eq!(parse_user_from_status(status), Some("root".to_string()));
}
#[test]
fn test_should_parse_user_from_status_with_different_host() {
let status = r"gitlab.com
✓ Logged in to gitlab.com as alice (oauth_token)
✓ Token: glpat-****
";
assert_eq!(parse_user_from_status(status), Some("alice".to_string()));
}
#[test]
fn test_should_return_none_when_no_user_in_status() {
let status = "No active account found";
assert!(parse_user_from_status(status).is_none());
}
#[test]
fn test_should_return_none_for_empty_status() {
assert!(parse_user_from_status("").is_none());
}
#[test]
fn test_should_parse_user_without_suffix() {
let status = "Logged in to gitlab.com as bob";
assert_eq!(parse_user_from_status(status), Some("bob".to_string()));
}
#[test]
fn test_auth_checker_is_authenticated_with_env_var() {
use gitflow_core::AuthChecker;
temp_env::with_var("GL_TOKEN", Some("test_token"), || {
let provider = GitLabAuthProvider::new();
assert!(provider.is_authenticated());
});
}
#[test]
fn test_auth_checker_check_status_with_env_var() {
use gitflow_core::AuthChecker;
temp_env::with_var("GL_TOKEN", Some("test_token"), || {
let provider = GitLabAuthProvider::new();
let result = provider.check_status();
assert!(result.authenticated);
assert!(result.reason.is_none());
});
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_login() {
let runner = MockCommandRunner::failure("authentication failed", 256);
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.login(Some("glpat-token")).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_logout() {
let runner = MockCommandRunner::failure("not logged in", 256);
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.logout().await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_logged_out_status_when_glab_reports_not_logged_in() {
let runner = MockCommandRunner::failure("not logged in to any GitLab hosts", 256);
let provider = GitLabAuthProvider::with_runner(runner);
let status = provider.status().await.expect("graceful logged-out status");
assert!(!status.logged_in);
assert!(status.user.is_none());
}
#[tokio::test]
async fn test_should_return_platform_error_when_status_fails_unexpectedly() {
let runner = MockCommandRunner::failure("internal server error", 256);
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.status().await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_token() {
let runner = MockCommandRunner::failure("no token found", 256);
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.token().await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_empty_token_when_stdout_is_empty() {
let runner = MockCommandRunner::success("");
let provider = GitLabAuthProvider::with_runner(runner);
let token = provider
.token()
.await
.expect("empty stdout yields empty token");
assert!(token.is_empty());
}
#[test]
fn test_should_construct_with_custom_runner() {
let runner = MockCommandRunner::success("");
let provider = GitLabAuthProvider::with_runner(runner);
let debug = format!("{provider:?}");
assert!(debug.contains("GitLabAuthProvider"));
}
#[tokio::test]
async fn test_should_login_interactively() {
let runner = MockCommandRunner::success("");
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.login(None).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_should_login_with_token_via_stdin() {
let runner = MockCommandRunner::success("");
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.login(Some("glpat-secret-token")).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_should_logout_successfully() {
let runner = MockCommandRunner::success("");
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.logout().await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_should_return_logged_in_status_when_authenticated() {
let stdout = r"gitlab.com
✓ Logged in to gitlab.com as testuser (keyring)
✓ Git operations for gitlab.com configured to use ssh protocol.
";
let runner = MockCommandRunner::success(stdout);
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.status().await;
assert!(result.is_ok());
let status = result.unwrap();
assert!(status.logged_in);
assert_eq!(status.user, Some("testuser".to_string()));
assert!(status.scopes.is_empty());
}
#[tokio::test]
async fn test_should_return_token_successfully() {
let runner = MockCommandRunner::success("glpat-test12345\n");
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.token().await;
assert!(result.is_ok());
assert_eq!(result.unwrap(), "glpat-test12345");
}
#[tokio::test]
async fn test_should_trim_whitespace_from_token() {
let runner = MockCommandRunner::success(" glpat-test12345 \n\n");
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.token().await;
assert!(result.is_ok());
assert_eq!(result.unwrap(), "glpat-test12345");
}
#[tokio::test]
async fn test_should_return_platform_error_when_login_spawn_fails() {
let runner = MockCommandRunner::spawn_error();
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.login(None).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Platform(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_login_with_token_spawn_fails() {
let runner = MockCommandRunner::spawn_error();
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.login(Some("glpat-token")).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Platform(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_logout_spawn_fails() {
let runner = MockCommandRunner::spawn_error();
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.logout().await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Platform(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_status_spawn_fails() {
let runner = MockCommandRunner::spawn_error();
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.status().await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Platform(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_token_spawn_fails() {
let runner = MockCommandRunner::spawn_error();
let provider = GitLabAuthProvider::with_runner(runner);
let result = provider.token().await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Platform(_)
));
}
}