use std::path::{Path, PathBuf};
use std::process::{Command as StdCommand, ExitStatus};
use crate::git_env::scrub_git_env_std;
#[cfg(feature = "testing-tokio")]
use tokio::process::Command as TokioCommand;
const DEFAULT_NOTEBOOK: &str = "scratch";
const GIT_AUTHOR_NAME: &str = "nb-api tests";
const GIT_AUTHOR_EMAIL: &str = "nb-api@localhost";
#[derive(Debug)]
pub struct NbFailure {
pub status: ExitStatus,
pub stdout: String,
pub stderr: String,
}
impl std::fmt::Display for NbFailure {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"exit status: {}\nstdout: {}\nstderr: {}",
self.status,
if self.stdout.is_empty() {
"<empty>"
} else {
&self.stdout
},
if self.stderr.is_empty() {
"<empty>"
} else {
&self.stderr
},
)
}
}
impl std::error::Error for NbFailure {}
#[derive(Debug, thiserror::Error)]
pub enum NbTestError {
#[error("io error during {context}: {source}")]
Io {
context: String,
#[source]
source: std::io::Error,
},
#[error("nb command failed during {context}: {failure}")]
Nb {
context: String,
#[source]
failure: NbFailure,
},
}
#[derive(Debug, Default)]
pub struct NbTestEnvBuilder {
notebook: Option<String>,
working_directory: Option<PathBuf>,
}
impl NbTestEnvBuilder {
pub fn notebook(mut self, name: impl Into<String>) -> Self {
self.notebook = Some(name.into());
self
}
pub fn working_directory(mut self, path: impl Into<PathBuf>) -> Self {
self.working_directory = Some(path.into());
self
}
pub fn build(self) -> Result<NbTestEnv, NbTestError> {
let root = tempfile::Builder::new()
.prefix("nb-api-test-")
.tempdir()
.map_err(|e| NbTestError::Io {
context: "create isolated root tempdir".to_string(),
source: e,
})?;
let nb_dir = root.path().join(".nb");
std::fs::create_dir_all(&nb_dir).map_err(|e| NbTestError::Io {
context: format!("create nb dir at {}", nb_dir.display()),
source: e,
})?;
let working_dir = match self.working_directory {
Some(path) => path,
None => {
let path = root.path().join("work");
std::fs::create_dir_all(&path).map_err(|e| NbTestError::Io {
context: format!("create working dir at {}", path.display()),
source: e,
})?;
path
}
};
let home_dir = root.path().join("home");
std::fs::create_dir_all(&home_dir).map_err(|e| NbTestError::Io {
context: format!("create fixture HOME at {}", home_dir.display()),
source: e,
})?;
let notebook = self
.notebook
.unwrap_or_else(|| DEFAULT_NOTEBOOK.to_string());
let env = NbTestEnv {
root,
nb_dir,
working_dir,
home_dir,
notebook,
};
env.initialize_notebook()?;
Ok(env)
}
}
pub struct NbTestEnv {
#[allow(dead_code)]
root: tempfile::TempDir,
nb_dir: PathBuf,
working_dir: PathBuf,
home_dir: PathBuf,
notebook: String,
}
impl NbTestEnv {
pub fn new() -> Result<Self, NbTestError> {
Self::builder().build()
}
pub fn builder() -> NbTestEnvBuilder {
NbTestEnvBuilder::default()
}
pub fn nb_dir(&self) -> &Path {
&self.nb_dir
}
pub fn working_dir(&self) -> &Path {
&self.working_dir
}
pub fn home_dir(&self) -> &Path {
&self.home_dir
}
pub fn notebook(&self) -> &str {
&self.notebook
}
pub fn configure_std(&self, cmd: &mut StdCommand) {
scrub_git_env_std(cmd);
cmd.env("NB_DIR", &self.nb_dir);
cmd.env("HOME", &self.home_dir);
cmd.env("GIT_AUTHOR_NAME", GIT_AUTHOR_NAME);
cmd.env("GIT_AUTHOR_EMAIL", GIT_AUTHOR_EMAIL);
cmd.env("GIT_COMMITTER_NAME", GIT_AUTHOR_NAME);
cmd.env("GIT_COMMITTER_EMAIL", GIT_AUTHOR_EMAIL);
cmd.env("GIT_CONFIG_COUNT", "2");
cmd.env("GIT_CONFIG_KEY_0", "commit.gpgsign");
cmd.env("GIT_CONFIG_VALUE_0", "false");
cmd.env("GIT_CONFIG_KEY_1", "tag.gpgsign");
cmd.env("GIT_CONFIG_VALUE_1", "false");
cmd.current_dir(&self.working_dir);
}
#[cfg(feature = "testing-tokio")]
pub fn configure_tokio(&self, cmd: &mut TokioCommand) {
crate::git_env::scrub_git_env(cmd);
cmd.env("NB_DIR", &self.nb_dir);
cmd.env("HOME", &self.home_dir);
cmd.env("GIT_AUTHOR_NAME", GIT_AUTHOR_NAME);
cmd.env("GIT_AUTHOR_EMAIL", GIT_AUTHOR_EMAIL);
cmd.env("GIT_COMMITTER_NAME", GIT_AUTHOR_NAME);
cmd.env("GIT_COMMITTER_EMAIL", GIT_AUTHOR_EMAIL);
cmd.env("GIT_CONFIG_COUNT", "2");
cmd.env("GIT_CONFIG_KEY_0", "commit.gpgsign");
cmd.env("GIT_CONFIG_VALUE_0", "false");
cmd.env("GIT_CONFIG_KEY_1", "tag.gpgsign");
cmd.env("GIT_CONFIG_VALUE_1", "false");
cmd.current_dir(&self.working_dir);
}
pub fn nb_command(&self) -> StdCommand {
let mut cmd = StdCommand::new("nb");
self.configure_std(&mut cmd);
cmd
}
#[cfg(feature = "testing-tokio")]
pub fn nb_command_async(&self) -> TokioCommand {
let mut cmd = TokioCommand::new("nb");
self.configure_tokio(&mut cmd);
cmd
}
fn initialize_notebook(&self) -> Result<(), NbTestError> {
let gitconfig = self.home_dir.join(".gitconfig");
let gitconfig_contents =
format!("[user]\n\tname = {GIT_AUTHOR_NAME}\n\temail = {GIT_AUTHOR_EMAIL}\n",);
std::fs::write(&gitconfig, gitconfig_contents).map_err(|e| NbTestError::Io {
context: format!("write .gitconfig to {}", gitconfig.display()),
source: e,
})?;
let init_stub = self.nb_dir.join(".init_stub");
std::fs::create_dir_all(&init_stub).map_err(|e| NbTestError::Io {
context: format!("create init stub at {}", init_stub.display()),
source: e,
})?;
let mut cmd = StdCommand::new("nb");
scrub_git_env_std(&mut cmd);
cmd.env("NB_DIR", &self.nb_dir);
cmd.env("NB_NOTEBOOK_PATH", &init_stub);
cmd.env("HOME", &self.home_dir);
cmd.env("GIT_AUTHOR_NAME", GIT_AUTHOR_NAME);
cmd.env("GIT_AUTHOR_EMAIL", GIT_AUTHOR_EMAIL);
cmd.env("GIT_COMMITTER_NAME", GIT_AUTHOR_NAME);
cmd.env("GIT_COMMITTER_EMAIL", GIT_AUTHOR_EMAIL);
cmd.env("GIT_CONFIG_COUNT", "2");
cmd.env("GIT_CONFIG_KEY_0", "commit.gpgsign");
cmd.env("GIT_CONFIG_VALUE_0", "false");
cmd.env("GIT_CONFIG_KEY_1", "tag.gpgsign");
cmd.env("GIT_CONFIG_VALUE_1", "false");
cmd.current_dir(&self.working_dir);
cmd.arg("notebooks").arg("add").arg(&self.notebook);
let output = cmd.output().map_err(|e| NbTestError::Io {
context: format!("spawn `nb notebooks add {}`", self.notebook),
source: e,
})?;
if !output.status.success() {
let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
return Err(NbTestError::Nb {
context: format!("`nb notebooks add {}`", self.notebook),
failure: NbFailure {
status: output.status,
stdout,
stderr,
},
});
}
std::fs::write(self.nb_dir.join(".current"), &self.notebook).map_err(|e| {
NbTestError::Io {
context: format!(
"write .current to {}",
self.nb_dir.join(".current").display()
),
source: e,
}
})?;
Ok(())
}
}