#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![warn(missing_debug_implementations)]
use std::process::ExitStatus;
#[derive(Debug, Clone)]
pub struct CommandOutput {
pub status: ExitStatus,
pub stdout: Vec<u8>,
pub stderr: Vec<u8>,
}
#[async_trait::async_trait]
pub trait CommandRunner: std::fmt::Debug + Send + Sync {
async fn run(&self, program: &str, args: &[&str]) -> std::io::Result<CommandOutput>;
async fn run_with_stdin(
&self,
program: &str,
args: &[&str],
stdin_data: &[u8],
) -> std::io::Result<CommandOutput>;
}
#[derive(Debug, Clone, Default)]
pub struct RealCommandRunner;
#[async_trait::async_trait]
impl CommandRunner for RealCommandRunner {
async fn run(&self, program: &str, args: &[&str]) -> std::io::Result<CommandOutput> {
let output = tokio::process::Command::new(program)
.args(args)
.output()
.await?;
Ok(CommandOutput {
status: output.status,
stdout: output.stdout,
stderr: output.stderr,
})
}
async fn run_with_stdin(
&self,
program: &str,
args: &[&str],
stdin_data: &[u8],
) -> std::io::Result<CommandOutput> {
use tokio::io::AsyncWriteExt;
let mut child = tokio::process::Command::new(program)
.args(args)
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.spawn()?;
if let Some(mut stdin) = child.stdin.take() {
stdin.write_all(stdin_data).await?;
drop(stdin);
}
let output = child.wait_with_output().await?;
Ok(CommandOutput {
status: output.status,
stdout: output.stdout,
stderr: output.stderr,
})
}
}
pub trait EnvSource: std::fmt::Debug + Send + Sync {
fn var(&self, key: &str) -> Option<String>;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct RealEnv;
impl EnvSource for RealEnv {
fn var(&self, key: &str) -> Option<String> {
std::env::var(key).ok()
}
}
#[cfg(feature = "test-util")]
#[derive(Debug, Clone, Default)]
pub struct MockEnv {
vars: std::collections::HashMap<String, String>,
}
#[cfg(feature = "test-util")]
impl MockEnv {
#[must_use]
pub fn empty() -> Self {
Self::default()
}
#[must_use]
pub fn with(key: &str, value: &str) -> Self {
let mut vars = std::collections::HashMap::new();
vars.insert(key.to_string(), value.to_string());
Self { vars }
}
}
#[cfg(feature = "test-util")]
impl EnvSource for MockEnv {
fn var(&self, key: &str) -> Option<String> {
self.vars.get(key).cloned()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "test-util")]
#[test]
fn test_should_return_none_from_mock_env_when_key_absent() {
let env = MockEnv::empty();
assert_eq!(env.var("GL_TOKEN"), None);
}
#[cfg(feature = "test-util")]
#[test]
fn test_should_return_value_from_mock_env_when_key_present() {
let env = MockEnv::with("GL_TOKEN", "glpat-mock");
assert_eq!(env.var("GL_TOKEN"), Some("glpat-mock".to_string()));
}
#[cfg(feature = "test-util")]
#[test]
fn test_should_isolate_unrelated_keys_in_mock_env() {
let env = MockEnv::with("GL_TOKEN", "glpat-mock");
assert_eq!(env.var("GITLAB_HOST"), None);
}
#[test]
fn test_should_read_real_process_env_through_real_env() {
let env = RealEnv;
assert!(env.var("PATH").is_some());
}
#[test]
fn test_should_return_none_from_real_env_for_absent_key() {
let env = RealEnv;
assert_eq!(env.var("GF_DEFINITELY_NOT_SET_12345"), None);
}
}