use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::process::{Command as StdCommand, ExitStatus, Stdio};
use std::sync::OnceLock;
use crate::git_env::scrub_git_env_std;
use crate::nb_program::nb_candidate_names;
#[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";
fn apply_git_config_env(cmd: &mut impl GitEnvSetter) {
cmd.env("GIT_CONFIG_COUNT", "4");
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.env("GIT_CONFIG_KEY_2", "core.autocrlf");
cmd.env("GIT_CONFIG_VALUE_2", "false");
cmd.env("GIT_CONFIG_KEY_3", "core.eol");
cmd.env("GIT_CONFIG_VALUE_3", "lf");
}
trait GitEnvSetter {
fn env<K, V>(&mut self, key: K, value: V)
where
K: AsRef<std::ffi::OsStr>,
V: AsRef<std::ffi::OsStr>;
}
impl GitEnvSetter for StdCommand {
fn env<K, V>(&mut self, key: K, value: V)
where
K: AsRef<std::ffi::OsStr>,
V: AsRef<std::ffi::OsStr>,
{
StdCommand::env(self, key, value);
}
}
#[cfg(feature = "testing-tokio")]
impl GitEnvSetter for TokioCommand {
fn env<K, V>(&mut self, key: K, value: V)
where
K: AsRef<std::ffi::OsStr>,
V: AsRef<std::ffi::OsStr>,
{
TokioCommand::env(self, key, value);
}
}
const SAFE_PATH_DIRS: &[&str] = &[
"/opt/homebrew/bin",
"/opt/homebrew/sbin",
"/usr/local/bin",
"/usr/local/sbin",
"/usr/bin",
"/bin",
"/usr/sbin",
"/sbin",
];
static NB_BINARY: OnceLock<PathBuf> = OnceLock::new();
static CHILD_PATH: OnceLock<OsString> = OnceLock::new();
pub fn nb_binary() -> &'static Path {
NB_BINARY.get_or_init(discover_nb_binary).as_path()
}
pub fn fixture_child_path() -> &'static OsString {
CHILD_PATH.get_or_init(|| {
let nb = nb_binary();
let mut dirs: Vec<PathBuf> = Vec::new();
if let Some(parent) = nb.parent() {
dirs.push(parent.to_path_buf());
}
for d in SAFE_PATH_DIRS {
let p = PathBuf::from(d);
if !dirs.iter().any(|x| x == &p) {
dirs.push(p);
}
}
std::env::join_paths(dirs).unwrap_or_else(|_| OsString::from("/usr/bin:/bin"))
})
}
fn discover_nb_binary() -> PathBuf {
if let Some(explicit) = std::env::var_os("NB_API_TEST_NB") {
return resolve_nb_override(Path::new(&explicit)).unwrap_or_else(|reason| {
panic!("nb-api testing: invalid NB_API_TEST_NB: {reason}");
});
}
let names = nb_candidate_names();
let mut candidates: Vec<PathBuf> = Vec::new();
for d in SAFE_PATH_DIRS {
for name in &names {
candidates.push(PathBuf::from(d).join(name));
}
}
if let Some(home) = login_home_dir() {
for name in &names {
candidates.push(home.join(".local/bin").join(name));
}
}
if let Some(path_var) = std::env::var_os("PATH") {
for dir in std::env::split_paths(&path_var) {
if path_dir_looks_poisoned(&dir) || !dir.is_absolute() {
continue;
}
for name in &names {
candidates.push(dir.join(name));
}
}
}
let mut tried = Vec::new();
for c in &candidates {
tried.push(c.clone());
if let Some(abs) = canonicalize_executable(c) {
return abs;
}
}
panic!(
"nb-api testing: could not locate an executable `nb` binary. \
Install nb 7.24.0 or set NB_API_TEST_NB to its absolute path. \
candidates tried: {tried:?}"
);
}
fn resolve_nb_override(path: &Path) -> Result<PathBuf, String> {
if !path.is_absolute() {
return Err(format!(
"path must be absolute (got relative {:?}); \
relative overrides break after fixture current_dir changes",
path
));
}
canonicalize_executable(path).ok_or_else(|| {
format!(
"path is not an executable file after canonicalize: {:?}",
path
)
})
}
fn canonicalize_executable(path: &Path) -> Option<PathBuf> {
if !path.is_absolute() {
return None;
}
let canonical = path.canonicalize().ok()?;
if !is_executable_file(&canonical) {
return None;
}
Some(canonical)
}
fn path_dir_looks_poisoned(dir: &Path) -> bool {
let s = dir.to_string_lossy();
s.contains("poisoned")
|| s.contains("nb-shim-")
|| s == "/nonexistent"
|| s.starts_with("/nonexistent")
}
fn is_executable_file(path: &Path) -> bool {
let Ok(meta) = std::fs::metadata(path) else {
return false;
};
if !meta.is_file() {
return false;
}
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
meta.permissions().mode() & 0o111 != 0
}
#[cfg(windows)]
{
has_spawnable_windows_extension(path)
}
#[cfg(not(any(unix, windows)))]
{
true
}
}
#[cfg(windows)]
fn has_spawnable_windows_extension(path: &Path) -> bool {
path.extension().is_some_and(|ext| {
let ext = ext.to_string_lossy().to_ascii_lowercase();
matches!(ext.as_str(), "com" | "exe" | "bat" | "cmd")
})
}
fn login_home_dir() -> Option<PathBuf> {
#[cfg(unix)]
{
if let Some(home) = home_from_id_p() {
return Some(home);
}
if let Some(home) = home_from_dscl() {
return Some(home);
}
home_from_etc_passwd_uid()
}
#[cfg(not(unix))]
{
std::env::var_os("USERPROFILE")
.or_else(|| std::env::var_os("HOME"))
.map(PathBuf::from)
}
}
#[cfg(unix)]
fn home_from_id_p() -> Option<PathBuf> {
for id_bin in ["/usr/bin/id", "/bin/id"] {
let output = match StdCommand::new(id_bin).arg("-P").output() {
Ok(o) => o,
Err(_) => continue,
};
if !output.status.success() {
continue;
}
let stdout = String::from_utf8_lossy(&output.stdout);
let line = stdout.lines().next()?;
if let Some(home) = home_from_passwd_style_line(line) {
return Some(home);
}
}
None
}
#[cfg(unix)]
fn home_from_dscl() -> Option<PathBuf> {
let user = current_username()?;
let output = match StdCommand::new("/usr/bin/dscl")
.args([".", "-read", &format!("/Users/{user}"), "NFSHomeDirectory"])
.output()
{
Ok(o) => o,
Err(_) => return None,
};
if !output.status.success() {
return None;
}
let stdout = String::from_utf8_lossy(&output.stdout);
parse_dscl_home(&stdout)
}
#[cfg(unix)]
fn home_from_etc_passwd_uid() -> Option<PathBuf> {
let uid = current_uid()?;
let passwd = std::fs::read_to_string("/etc/passwd").ok()?;
for line in passwd.lines() {
let mut fields = line.split(':');
let _name = fields.next()?;
let _passwd = fields.next()?;
let file_uid = fields.next()?.parse::<u32>().ok()?;
if file_uid != uid {
continue;
}
let _gid = fields.next()?;
let _gecos = fields.next()?;
let home = fields.next()?;
if !home.is_empty() {
return Some(PathBuf::from(home));
}
}
None
}
#[cfg_attr(not(unix), allow(dead_code))]
fn home_from_passwd_style_line(line: &str) -> Option<PathBuf> {
let fields: Vec<&str> = line.trim().split(':').collect();
let home = if fields.len() >= 10 {
fields[8]
} else if fields.len() >= 7 {
fields[5]
} else {
return None;
};
if home.is_empty() {
None
} else {
Some(PathBuf::from(home))
}
}
#[cfg_attr(not(unix), allow(dead_code))]
fn parse_dscl_home(stdout: &str) -> Option<PathBuf> {
for line in stdout.lines() {
let line = line.trim();
let Some(rest) = line
.strip_prefix("NFSHomeDirectory:")
.or_else(|| line.strip_prefix("dsAttrTypeNative:NFSHomeDirectory:"))
else {
continue;
};
let home = rest.trim();
if !home.is_empty() {
return Some(PathBuf::from(home));
}
}
None
}
#[cfg(unix)]
fn current_username() -> Option<String> {
for id_bin in ["/usr/bin/id", "/bin/id"] {
let output = match StdCommand::new(id_bin).arg("-un").output() {
Ok(o) => o,
Err(_) => continue,
};
if !output.status.success() {
continue;
}
let name = String::from_utf8_lossy(&output.stdout).trim().to_string();
if !name.is_empty() {
return Some(name);
}
}
None
}
#[cfg(unix)]
fn current_uid() -> Option<u32> {
for id_bin in ["/usr/bin/id", "/bin/id"] {
let output = match StdCommand::new(id_bin).arg("-u").output() {
Ok(o) => o,
Err(_) => continue,
};
if !output.status.success() {
continue;
}
let stdout = String::from_utf8_lossy(&output.stdout);
if let Ok(uid) = stdout.trim().parse::<u32>() {
return Some(uid);
}
}
let status = std::fs::read_to_string("/proc/self/status").ok()?;
for line in status.lines() {
let Some(rest) = line.strip_prefix("Uid:") else {
continue;
};
return rest.split_whitespace().next()?.parse().ok();
}
None
}
#[cfg(test)]
mod nb_resolve_tests {
use super::*;
use std::path::PathBuf;
#[test]
fn relative_nb_override_is_rejected() {
let err = resolve_nb_override(Path::new("relative/nb")).unwrap_err();
assert!(
err.contains("absolute"),
"expected absolute-path error, got {err}"
);
}
#[test]
fn relative_candidate_is_not_canonicalized() {
assert!(canonicalize_executable(Path::new("nb")).is_none());
assert!(canonicalize_executable(Path::new("./nb")).is_none());
}
#[test]
fn safe_path_dirs_include_homebrew_prefix() {
assert!(
SAFE_PATH_DIRS.contains(&"/opt/homebrew/bin"),
"Apple Silicon Homebrew must be in SAFE_PATH_DIRS for poisoned-PATH discovery"
);
}
#[test]
fn parses_macos_id_p_home_field() {
let line = "me:********:501:20::0:0:Me:/Users/me:/bin/zsh";
assert_eq!(
home_from_passwd_style_line(line),
Some(PathBuf::from("/Users/me"))
);
}
#[test]
fn parses_traditional_passwd_home_field() {
let line = "me:x:1000:1000:Me:/home/me:/bin/bash";
assert_eq!(
home_from_passwd_style_line(line),
Some(PathBuf::from("/home/me"))
);
}
#[test]
fn parses_dscl_nfs_home_directory() {
assert_eq!(
parse_dscl_home("NFSHomeDirectory: /Users/me\n"),
Some(PathBuf::from("/Users/me"))
);
assert_eq!(
parse_dscl_home("dsAttrTypeNative:NFSHomeDirectory: /Users/me\n"),
Some(PathBuf::from("/Users/me"))
);
}
#[cfg(unix)]
#[test]
fn absolute_executable_is_canonicalized() {
use std::fs;
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().expect("tempdir");
let bin = dir.path().join("fake-nb");
fs::write(&bin, b"#!/bin/sh\n").expect("write");
fs::set_permissions(&bin, fs::Permissions::from_mode(0o755)).expect("chmod");
let abs = bin.canonicalize().expect("canonicalize fixture path");
let got = canonicalize_executable(&abs).expect("accept absolute executable");
assert!(got.is_absolute());
assert_eq!(got, abs);
}
}
#[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("PATH", fixture_child_path());
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);
apply_git_config_env(cmd);
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("PATH", fixture_child_path());
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);
apply_git_config_env(cmd);
cmd.current_dir(&self.working_dir);
}
pub fn nb_command(&self) -> StdCommand {
let mut cmd = StdCommand::new(nb_binary());
self.configure_std(&mut cmd);
cmd.stdin(Stdio::null());
cmd
}
#[cfg(feature = "testing-tokio")]
pub fn nb_command_async(&self) -> TokioCommand {
let mut cmd = TokioCommand::new(nb_binary());
self.configure_tokio(&mut cmd);
cmd.stdin(Stdio::null());
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_binary());
scrub_git_env_std(&mut cmd);
cmd.env("PATH", fixture_child_path());
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);
apply_git_config_env(&mut cmd);
cmd.stdin(Stdio::null()); 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,
}
})?;
let notebook_root = self.nb_dir.join(&self.notebook);
let baseline_result: Result<(), NbTestError> = (|| {
let mut git_config = StdCommand::new("git");
scrub_git_env_std(&mut git_config);
git_config.env("HOME", &self.home_dir);
apply_git_config_env(&mut git_config);
git_config.current_dir(¬ebook_root);
git_config.args(["config", "core.autocrlf", "false"]);
let cfg = git_config.output().map_err(|e| NbTestError::Io {
context: format!(
"fixture baseline `git config core.autocrlf false` in {}",
notebook_root.display()
),
source: e,
})?;
if !cfg.status.success() {
let stdout = String::from_utf8_lossy(&cfg.stdout).into_owned();
let stderr = String::from_utf8_lossy(&cfg.stderr).into_owned();
return Err(NbTestError::Nb {
context: format!(
"fixture baseline `git config core.autocrlf false` in {}",
notebook_root.display()
),
failure: NbFailure {
status: cfg.status,
stdout,
stderr,
},
});
}
let mut consecutive_clean = 0u32;
for _ in 0..50 {
let mut status = StdCommand::new("git");
scrub_git_env_std(&mut status);
status.env("HOME", &self.home_dir);
apply_git_config_env(&mut status);
status.current_dir(¬ebook_root);
status.args(["status", "--porcelain", "-uall", "--ignored=no"]);
let status_out = status.output().map_err(|e| NbTestError::Io {
context: format!(
"fixture baseline `git status --porcelain` in {}",
notebook_root.display()
),
source: e,
})?;
if !status_out.status.success() {
let stdout = String::from_utf8_lossy(&status_out.stdout).into_owned();
let stderr = String::from_utf8_lossy(&status_out.stderr).into_owned();
return Err(NbTestError::Nb {
context: format!(
"fixture baseline `git status --porcelain` in {}",
notebook_root.display()
),
failure: NbFailure {
status: status_out.status,
stdout,
stderr,
},
});
}
let dirty = !String::from_utf8_lossy(&status_out.stdout)
.trim()
.is_empty();
if !dirty {
consecutive_clean += 1;
if consecutive_clean >= 2 {
return Ok(());
}
} else {
consecutive_clean = 0;
}
let mut git = StdCommand::new("git");
scrub_git_env_std(&mut git);
git.env("HOME", &self.home_dir);
git.env("GIT_AUTHOR_NAME", GIT_AUTHOR_NAME);
git.env("GIT_AUTHOR_EMAIL", GIT_AUTHOR_EMAIL);
git.env("GIT_COMMITTER_NAME", GIT_AUTHOR_NAME);
git.env("GIT_COMMITTER_EMAIL", GIT_AUTHOR_EMAIL);
apply_git_config_env(&mut git);
git.current_dir(¬ebook_root);
git.arg("add").arg("-A");
let add = git.output().map_err(|e| NbTestError::Io {
context: format!(
"fixture baseline `git add -A` in {}",
notebook_root.display()
),
source: e,
})?;
if !add.status.success() {
let stdout = String::from_utf8_lossy(&add.stdout).into_owned();
let stderr = String::from_utf8_lossy(&add.stderr).into_owned();
return Err(NbTestError::Nb {
context: format!(
"fixture baseline `git add -A` in {}",
notebook_root.display()
),
failure: NbFailure {
status: add.status,
stdout,
stderr,
},
});
}
let mut git_commit = StdCommand::new("git");
scrub_git_env_std(&mut git_commit);
git_commit.env("HOME", &self.home_dir);
git_commit.env("GIT_AUTHOR_NAME", GIT_AUTHOR_NAME);
git_commit.env("GIT_AUTHOR_EMAIL", GIT_AUTHOR_EMAIL);
git_commit.env("GIT_COMMITTER_NAME", GIT_AUTHOR_NAME);
git_commit.env("GIT_COMMITTER_EMAIL", GIT_AUTHOR_EMAIL);
apply_git_config_env(&mut git_commit);
git_commit.current_dir(¬ebook_root);
git_commit.args(["commit", "-m", "[nb] Initialize"]);
let commit = git_commit.output().map_err(|e| NbTestError::Io {
context: format!(
"fixture baseline `git commit` in {}",
notebook_root.display()
),
source: e,
})?;
if !commit.status.success() {
let stdout = String::from_utf8_lossy(&commit.stdout);
let stderr = String::from_utf8_lossy(&commit.stderr);
if !stdout.contains("nothing to commit")
&& !stderr.contains("nothing to commit")
{
return Err(NbTestError::Nb {
context: format!(
"fixture baseline `git commit` in {}",
notebook_root.display()
),
failure: NbFailure {
status: commit.status,
stdout: stdout.into_owned(),
stderr: stderr.into_owned(),
},
});
}
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
Err(NbTestError::Io {
context: format!(
"fixture baseline did not settle clean in {}",
notebook_root.display()
),
source: std::io::Error::other("notebook repo never reached a clean baseline"),
})
})();
if let Err(NbTestError::Io { source, .. }) = &baseline_result
&& source.kind() == std::io::ErrorKind::NotFound
{
tracing::debug!("fixture baseline skipped: git not on process PATH");
} else {
baseline_result?;
}
Ok(())
}
}