mod common;
use std::process::{Command, Output, Stdio};
use common::{Answer, Daemon, Home, daemon};
use second_brain_sync::protocol::{Hello, SyncHeader};
const PINNED: &str = "pinned-device";
fn hello(id: &str) -> Hello {
Hello {
machine_id: id.to_string(),
wall_micros: 0,
synced: true,
cursor: None,
held_origin_seq: None,
keys: None,
peer_in: None,
log_floor: 0,
head: 0,
applied: None,
merging: None,
}
}
fn devices(revoked: bool) -> String {
serde_json::json!({
"identity": "x",
"devices": [{"machine_id": PINNED, "name": "p", "this_device": false, "revoked": revoked, "added_by": "x"}]
})
.to_string()
}
fn active(path: &str) -> (u16, String) {
match path {
"/v1/devices" => (200, devices(false)),
"/health" => (200, r#"{"machine_id":"daemon-local-id"}"#.to_string()),
"/v1/sync/version" => (200, serde_json::to_string(&SyncHeader::local()).unwrap()),
_ => (404, r#"{"error":"unexpected"}"#.to_string()),
}
}
fn revoked(path: &str) -> (u16, String) {
match path {
"/v1/devices" => (200, devices(true)),
_ => active(path),
}
}
fn serve(daemon: &Daemon, machine: &str, original: Option<&str>) -> Output {
let home = Home::new();
let mut command = Command::new(env!("CARGO_BIN_EXE_sb"));
command
.args(["sync-serve", "--machine", machine])
.env("HOME", home.path())
.env("SECOND_BRAIN_API", &daemon.base)
.env("SECOND_BRAIN_BIND", "127.0.0.1:9")
.env_remove("SSH_ORIGINAL_COMMAND")
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
if let Some(original) = original {
command.env("SSH_ORIGINAL_COMMAND", original);
}
command.output().unwrap()
}
fn paths(daemon: &Daemon) -> Vec<String> {
daemon
.requests()
.iter()
.map(|r| r.target.split_whitespace().nth(1).unwrap().to_string())
.collect()
}
#[test]
fn a_refused_command_exits_non_zero_without_reaching_the_daemon() {
let d = daemon(Answer::Routed(active));
for original in [
None,
Some(""),
Some("sync-status"),
Some("sb sync-trust x"),
Some("sh -c whoami"),
Some("sb whoami extra"),
] {
let out = serve(&d, PINNED, original);
assert!(!out.status.success(), "{original:?}");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("sync-snapshot"), "{original:?}: {stderr}");
}
assert!(d.requests().is_empty(), "{:?}", paths(&d));
}
#[test]
fn a_bad_machine_argument_is_a_usage_error() {
let d = daemon(Answer::Routed(active));
let out = serve(&d, "bad id;", Some("whoami"));
assert!(!out.status.success());
assert!(String::from_utf8_lossy(&out.stderr).contains("usage"));
assert!(d.requests().is_empty());
}
#[test]
fn whoami_for_an_active_pinned_device_reads_the_daemon_health() {
let d = daemon(Answer::Routed(active));
let out = serve(&d, PINNED, Some("/home/x/.cargo/bin/sb whoami"));
assert!(
out.status.success(),
"{}",
String::from_utf8_lossy(&out.stderr)
);
assert_eq!(String::from_utf8_lossy(&out.stdout), "daemon-local-id\n");
assert_eq!(paths(&d), ["/v1/devices", "/health"]);
}
#[test]
fn an_export_hello_naming_another_machine_never_reaches_sync_export() {
let d = daemon(Answer::Routed(active));
let original = format!(
"sb sync-export --after-seq 0 --hello {}",
hello("other").to_arg()
);
let out = serve(&d, PINNED, Some(&original));
assert!(!out.status.success());
assert!(String::from_utf8_lossy(&out.stderr).contains("other"));
assert!(
!paths(&d).iter().any(|p| p == "/v1/sync/export"),
"{:?}",
paths(&d)
);
}
#[test]
fn an_export_hello_naming_the_pinned_machine_is_forwarded() {
let d = daemon(Answer::Routed(|path| match path {
"/v1/sync/export" => (200, r#"{"lines":[],"max_seq":0}"#.to_string()),
other => active(other),
}));
let original = format!(
"sb sync-export --after-seq 0 --hello {}",
hello(PINNED).to_arg()
);
let out = serve(&d, PINNED, Some(&original));
assert!(
out.status.success(),
"{}",
String::from_utf8_lossy(&out.stderr)
);
assert!(paths(&d).iter().any(|p| p == "/v1/sync/export"));
}
#[test]
fn a_revoked_pinned_device_is_refused_before_any_command_runs() {
let d = daemon(Answer::Routed(revoked));
let out = serve(&d, PINNED, Some("sb whoami"));
assert!(!out.status.success());
assert!(String::from_utf8_lossy(&out.stderr).contains("revoked"));
assert_eq!(paths(&d), ["/v1/devices"]);
}
#[test]
fn an_unlisted_pinned_device_is_refused() {
let d = daemon(Answer::Routed(active));
let out = serve(&d, "someone-else", Some("sb whoami"));
assert!(!out.status.success());
assert!(String::from_utf8_lossy(&out.stderr).contains("not paired"));
assert_eq!(paths(&d), ["/v1/devices"]);
}
#[test]
fn an_import_stream_naming_another_machine_is_refused_before_the_daemon_imports() {
let d = daemon(Answer::Routed(active));
let header = SyncHeader {
hello: Some(hello("other")),
..SyncHeader::local()
};
let home = Home::new();
let mut child = Command::new(env!("CARGO_BIN_EXE_sb"))
.args(["sync-serve", "--machine", PINNED])
.env("HOME", home.path())
.env("SECOND_BRAIN_API", &d.base)
.env("SSH_ORIGINAL_COMMAND", "sb sync-import")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.unwrap();
{
use std::io::Write;
let mut stdin = child.stdin.take().unwrap();
writeln!(stdin, "{}", header.to_line()).unwrap();
}
let out = child.wait_with_output().unwrap();
assert!(!out.status.success());
assert!(
!paths(&d).iter().any(|p| p == "/v1/sync/import"),
"{:?}",
paths(&d)
);
}