use std::path::{Path, PathBuf};
use std::process::{Command, Output};
const PACKAGES: [(&str, &str); 3] = [
("second-brain-api", "second-brain-api"),
("second-brain-mcp", "second-brain-mcp"),
("second-brain-cli", "sb"),
];
struct Fixture {
_root: tempfile::TempDir,
home: PathBuf,
release: PathBuf,
shims: PathBuf,
}
impl Fixture {
fn new() -> Self {
let root = tempfile::tempdir().unwrap();
let home = root.path().join("home");
let release = root.path().join("release");
let shims = root.path().join("shims");
for dir in [&home, &release, &shims] {
std::fs::create_dir_all(dir).unwrap();
}
for (package, bin) in PACKAGES {
write_installer(&release, package, bin, "setup-ok");
}
let curl = which("curl");
write_executable(
&shims.join("curl"),
&format!(
"#!/bin/sh\necho \"$*\" >> \"$HOME/downloads\"\nexec {} \"$@\"\n",
curl.display()
),
);
write_executable(&shims.join("sysctl"), "#!/bin/sh\nexit 1\n");
Fixture {
_root: root,
home,
release,
shims,
}
}
fn cargo_bin(&self) -> PathBuf {
self.home.join(".cargo/bin")
}
fn uname(&self, system: &str, machine: &str) {
write_executable(
&self.shims.join("uname"),
&format!("#!/bin/sh\ncase \"$1\" in -s) echo {system} ;; -m) echo {machine} ;; esac\n"),
);
}
fn arm64_hardware(&self) {
write_executable(
&self.shims.join("sysctl"),
"#!/bin/sh\n[ \"$*\" = \"-n hw.optional.arm64\" ] && echo 1\n",
);
}
fn run(&self) -> Output {
self.run_with_cargo_home(None)
}
fn run_with_cargo_home(&self, cargo_home: Option<&Path>) -> Output {
let script = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/install.sh");
let path = format!(
"{}:{}",
self.shims.display(),
std::env::var("PATH").unwrap_or_default()
);
let mut cmd = Command::new("sh");
cmd.arg(script)
.env_clear()
.env("PATH", path)
.env("HOME", &self.home)
.env(
"SECOND_BRAIN_RELEASE_URL",
format!("file://{}", self.release.display()),
);
if let Some(dir) = cargo_home {
cmd.env("CARGO_HOME", dir);
}
cmd.output().unwrap()
}
fn read(&self, name: &str) -> String {
std::fs::read_to_string(self.home.join(name)).unwrap_or_default()
}
}
fn which(name: &str) -> PathBuf {
std::env::split_paths(&std::env::var_os("PATH").unwrap_or_default())
.map(|dir| dir.join(name))
.find(|path| path.is_file())
.unwrap_or_else(|| panic!("{name} is not on PATH"))
}
fn write_executable(path: &Path, body: &str) {
std::fs::write(path, body).unwrap();
let mut perms = std::fs::metadata(path).unwrap().permissions();
std::os::unix::fs::PermissionsExt::set_mode(&mut perms, 0o755);
std::fs::set_permissions(path, perms).unwrap();
}
fn write_installer(release: &Path, package: &str, bin: &str, setup: &str) {
let fake_bin = match setup {
"setup-ok" => "echo \"$*\" >> \"$HOME/sb-calls\"",
_ => "echo \"$*\" >> \"$HOME/sb-calls\"; exit 4",
};
let body = format!(
"#!/bin/sh\nset -eu\n\
dir=\"${{CARGO_HOME:-$HOME/.cargo}}/bin\"\n\
mkdir -p \"$dir\"\n\
printf '#!/bin/sh\\n%s\\n' '{fake_bin}' > \"$dir/{bin}\"\n\
chmod +x \"$dir/{bin}\"\n\
echo {package} >> \"$HOME/installers\"\n"
);
std::fs::write(release.join(format!("{package}-installer.sh")), body).unwrap();
}
fn stderr(out: &Output) -> String {
String::from_utf8_lossy(&out.stderr).into_owned()
}
#[test]
fn installs_every_package_then_runs_setup_once() {
let fx = Fixture::new();
fx.uname("Linux", "x86_64");
let out = fx.run();
assert!(out.status.success(), "{}", stderr(&out));
let mut installed: Vec<String> = fx.read("installers").lines().map(String::from).collect();
installed.sort();
assert_eq!(
installed,
["second-brain-api", "second-brain-cli", "second-brain-mcp"]
);
assert_eq!(fx.read("sb-calls"), "setup\n");
for (_, bin) in PACKAGES {
assert!(fx.cargo_bin().join(bin).exists(), "{bin} not installed");
}
}
#[test]
fn every_supported_platform_installs() {
for (system, machine) in [
("Linux", "x86_64"),
("Linux", "aarch64"),
("Linux", "arm64"),
("Darwin", "arm64"),
] {
let fx = Fixture::new();
fx.uname(system, machine);
let out = fx.run();
assert!(out.status.success(), "{system} {machine}: {}", stderr(&out));
}
}
#[test]
fn an_unsupported_platform_stops_before_downloading() {
for (system, machine) in [
("Darwin", "x86_64"),
("FreeBSD", "amd64"),
("Linux", "armv7l"),
] {
let fx = Fixture::new();
fx.uname(system, machine);
let out = fx.run();
assert!(!out.status.success(), "{system} {machine} installed");
assert!(
stderr(&out).contains("no prebuilt release") && stderr(&out).contains("sb setup"),
"{system} {machine}: {}",
stderr(&out)
);
assert_eq!(fx.read("installers"), "");
assert_eq!(fx.read("downloads"), "", "{system} {machine} downloaded");
}
}
#[test]
fn an_apple_silicon_shell_under_rosetta_installs_the_arm64_release() {
let fx = Fixture::new();
fx.uname("Darwin", "x86_64");
fx.arm64_hardware();
let out = fx.run();
assert!(out.status.success(), "{}", stderr(&out));
assert_eq!(fx.read("sb-calls"), "setup\n");
}
#[test]
fn a_missing_installer_fails_without_running_setup() {
let fx = Fixture::new();
fx.uname("Linux", "x86_64");
std::fs::remove_file(fx.release.join("second-brain-mcp-installer.sh")).unwrap();
let out = fx.run();
assert!(!out.status.success());
assert!(
stderr(&out).contains("second-brain-mcp-installer.sh"),
"{}",
stderr(&out)
);
assert_eq!(fx.read("sb-calls"), "");
assert_eq!(fx.read("installers"), "");
}
#[test]
fn a_failing_setup_fails_the_install() {
let fx = Fixture::new();
fx.uname("Linux", "x86_64");
write_installer(&fx.release, "second-brain-cli", "sb", "setup-fails");
let out = fx.run();
assert!(!out.status.success());
assert_eq!(fx.read("sb-calls"), "setup\n");
assert!(stderr(&out).contains("sb doctor"), "{}", stderr(&out));
}
#[test]
fn cargo_home_decides_where_setup_is_run_from() {
let fx = Fixture::new();
fx.uname("Linux", "x86_64");
let cargo_home = fx.home.join("elsewhere");
let out = fx.run_with_cargo_home(Some(&cargo_home));
assert!(out.status.success(), "{}", stderr(&out));
assert!(cargo_home.join("bin/sb").exists());
assert_eq!(fx.read("sb-calls"), "setup\n");
}