#[cfg(test)]
mod tests {
use nu_protocol::{PipelineData, Span, Value};
use serde_json::json;
use std::str::FromStr;
use tempfile::TempDir;
use crate::error::Error;
use crate::nu::{commands, util, Engine};
use crate::store::{Frame, Store};
fn setup_test_env() -> (Store, Engine) {
use std::sync::OnceLock;
static RT: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
let rt = RT.get_or_init(|| tokio::runtime::Runtime::new().unwrap());
let _guard = rt.enter();
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let engine = Engine::new().unwrap();
(store, engine)
}
fn nu_eval(engine: &Engine, input: PipelineData, command: impl Into<String>) -> Value {
let engine = engine.clone();
let command = command.into();
std::thread::spawn(move || {
engine
.eval(input, command)
.unwrap()
.into_value(Span::test_data())
.unwrap()
})
.join()
.unwrap()
}
fn value_to_frame(value: Value) -> Frame {
let value = util::value_to_json(&value);
serde_json::from_value(value).expect("Failed to deserialize JSON into Frame")
}
fn setup_scru128_test_env() -> Engine {
let (_store, mut engine) = setup_test_env();
engine
.add_commands(vec![
Box::new(commands::scru128_command::Scru128Command::new()),
Box::new(commands::scru128_command::Scru128UnpackCommand::new()),
Box::new(commands::scru128_command::Scru128PackCommand::new()),
])
.unwrap();
engine
}
#[test]
fn test_append_command() {
let (store, mut engine) = setup_test_env();
engine.set_append_meta(&json!({"base": "meta"}));
engine
.add_commands(vec![Box::new(
commands::append_command::AppendCommand::new(store.clone()),
)])
.unwrap();
let frame = nu_eval(
&engine,
PipelineData::empty(),
r#""test content" | .append topic"#,
);
let frame = value_to_frame(frame);
assert_eq!(frame.topic, "topic");
assert_eq!(frame.meta.unwrap(), json!({"base": "meta"}));
let content = store.cas_read_sync(&frame.hash.unwrap()).unwrap();
assert_eq!(String::from_utf8(content).unwrap(), "test content");
let frame = nu_eval(
&engine,
PipelineData::empty(),
r#"{data: 123} | .append arecord"#,
);
let frame = value_to_frame(frame);
assert_eq!(frame.topic, "arecord");
assert_eq!(frame.meta.unwrap(), json!({"base": "meta"}));
let content = store.cas_read_sync(&frame.hash.unwrap()).unwrap();
let expected_json = serde_json::json!({"data": 123});
assert_eq!(
serde_json::from_slice::<serde_json::Value>(&content).unwrap(),
expected_json
);
let frame = nu_eval(
&engine,
PipelineData::empty(),
r#".append custom-meta --meta {foo: "bar"}"#,
);
let frame = value_to_frame(frame);
assert_eq!(frame.topic, "custom-meta");
assert_eq!(frame.meta.unwrap(), json!({"base": "meta", "foo": "bar"}));
assert!(frame.hash.is_none());
}
#[test]
fn test_append_meta_from_env() {
std::env::set_var(
commands::append_command::APPEND_META_ENV,
r#"{"service_id":"leaked"}"#,
);
let (store, mut engine) = setup_test_env();
std::env::remove_var(commands::append_command::APPEND_META_ENV);
engine
.add_commands(vec![Box::new(
commands::append_command::AppendCommand::new(store.clone()),
)])
.unwrap();
let frame = value_to_frame(nu_eval(&engine, PipelineData::empty(), r#".append a"#));
assert_eq!(frame.meta.unwrap(), json!({}));
let frame = value_to_frame(nu_eval(
&engine,
PipelineData::empty(),
r#"$env.XS_APPEND_META = '{"service_id": "svc"}'; .append b"#,
));
assert_eq!(frame.meta.unwrap(), json!({"service_id": "svc"}));
let frame = value_to_frame(nu_eval(
&engine,
PipelineData::empty(),
r#"$env.XS_APPEND_META = '{"service_id": "svc"}'; .append c --meta {k: 1}"#,
));
assert_eq!(frame.meta.unwrap(), json!({"service_id": "svc", "k": 1}));
}
#[test]
fn test_cas_command_string() {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::cas_command::CasCommand::new(
store.clone(),
))])
.unwrap();
let hash = store.cas_insert_sync("test content").unwrap();
let value = nu_eval(&engine, PipelineData::empty(), format!(".cas {hash}"));
let content = value.as_str().unwrap();
assert_eq!(content, "test content");
}
#[test]
fn test_cas_command_binary() {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::cas_command::CasCommand::new(
store.clone(),
))])
.unwrap();
let binary_data = vec![0, 159, 146, 150]; let hash = store.cas_insert_sync(&binary_data).unwrap();
let value = nu_eval(&engine, PipelineData::empty(), format!(".cas {hash}"));
assert!(matches!(value, Value::Binary { .. }));
let retrieved_data = value.as_binary().unwrap();
assert_eq!(retrieved_data, &binary_data);
}
#[test]
fn test_last_command() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::last_command::LastCommand::new(
store.clone(),
))])
.unwrap();
let _frame1 = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("content1")?)
.build(),
)
.unwrap();
let frame2 = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("content2")?)
.build(),
)
.unwrap();
let last_frame = nu_eval(&engine, PipelineData::empty(), ".last topic");
assert_eq!(
last_frame.get_data_by_key("id").unwrap().as_str().unwrap(),
frame2.id.to_string()
);
Ok(())
}
#[test]
fn test_last_command_no_topic() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::last_command::LastCommand::new(
store.clone(),
))])
.unwrap();
let _frame1 = store
.append(
Frame::builder("topic_a")
.hash(store.cas_insert_sync("content1")?)
.build(),
)
.unwrap();
let frame2 = store
.append(
Frame::builder("topic_b")
.hash(store.cas_insert_sync("content2")?)
.build(),
)
.unwrap();
let last_frame = nu_eval(&engine, PipelineData::empty(), ".last");
assert_eq!(
last_frame.get_data_by_key("id").unwrap().as_str().unwrap(),
frame2.id.to_string()
);
Ok(())
}
#[test]
fn test_last_command_count() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::last_command::LastCommand::new(
store.clone(),
))])
.unwrap();
let frame1 = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("content1")?)
.build(),
)
.unwrap();
let frame2 = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("content2")?)
.build(),
)
.unwrap();
let frame3 = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("content3")?)
.build(),
)
.unwrap();
let result = nu_eval(&engine, PipelineData::empty(), ".last 2");
let frames = result.as_list().unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(
frames[0].get_data_by_key("id").unwrap().as_str().unwrap(),
frame2.id.to_string()
);
assert_eq!(
frames[1].get_data_by_key("id").unwrap().as_str().unwrap(),
frame3.id.to_string()
);
let result = nu_eval(&engine, PipelineData::empty(), ".last 1");
assert_eq!(
result.get_data_by_key("id").unwrap().as_str().unwrap(),
frame3.id.to_string()
);
let result = nu_eval(&engine, PipelineData::empty(), ".last 10");
let frames = result.as_list().unwrap();
assert_eq!(frames.len(), 3);
assert_eq!(
frames[0].get_data_by_key("id").unwrap().as_str().unwrap(),
frame1.id.to_string()
);
Ok(())
}
#[test]
fn test_last_command_topic_with_count() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::last_command::LastCommand::new(
store.clone(),
))])
.unwrap();
let _other = store
.append(
Frame::builder("other")
.hash(store.cas_insert_sync("other")?)
.build(),
)
.unwrap();
let frame1 = store
.append(
Frame::builder("target")
.hash(store.cas_insert_sync("content1")?)
.build(),
)
.unwrap();
let frame2 = store
.append(
Frame::builder("target")
.hash(store.cas_insert_sync("content2")?)
.build(),
)
.unwrap();
let result = nu_eval(&engine, PipelineData::empty(), ".last target 2");
let frames = result.as_list().unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(
frames[0].get_data_by_key("id").unwrap().as_str().unwrap(),
frame1.id.to_string()
);
assert_eq!(
frames[1].get_data_by_key("id").unwrap().as_str().unwrap(),
frame2.id.to_string()
);
Ok(())
}
#[test]
fn test_cat_command() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::cat_command::CatCommand::new(
store.clone(),
))])
.unwrap();
let _frame1 = store
.append(
Frame::builder("topic1")
.hash(store.cas_insert_sync("content1")?)
.build(),
)
.unwrap();
let _frame2 = store
.append(
Frame::builder("topic2")
.hash(store.cas_insert_sync("content2")?)
.build(),
)
.unwrap();
let value = nu_eval(&engine, PipelineData::empty(), ".cat");
let frames = value.as_list().unwrap();
assert_eq!(frames.len(), 2);
let value = nu_eval(&engine, PipelineData::empty(), ".cat --limit 1");
let frames = value.as_list().unwrap();
assert_eq!(frames.len(), 1);
let value = nu_eval(&engine, PipelineData::empty(), ".cat --topic topic2");
let frames = value.as_list().unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(
frames[0]
.get_data_by_key("topic")
.unwrap()
.as_str()
.unwrap(),
"topic2"
);
Ok(())
}
#[test]
fn test_remove_command() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(
commands::remove_command::RemoveCommand::new(store.clone()),
)])
.unwrap();
let frame = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("test")?)
.build(),
)
.unwrap();
nu_eval(
&engine,
PipelineData::empty(),
format!(".remove {}", frame.id),
);
assert!(store.get(&frame.id).is_none());
Ok(())
}
#[test]
fn test_get_command() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::get_command::GetCommand::new(
store.clone(),
))])
.unwrap();
let frame = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("test")?)
.build(),
)
.unwrap();
let retrieved_frame = nu_eval(&engine, PipelineData::empty(), format!(".get {}", frame.id));
assert_eq!(
retrieved_frame
.get_data_by_key("id")
.unwrap()
.as_str()
.unwrap(),
frame.id.to_string()
);
Ok(())
}
#[test]
fn test_scru128_generate() {
let engine = setup_scru128_test_env();
let id_value = nu_eval(&engine, PipelineData::empty(), ".id");
let id_string = id_value.as_str().unwrap();
assert!(id_string.len() > 20); assert!(scru128::Scru128Id::from_str(id_string).is_ok()); }
#[test]
fn test_scru128_unpack() {
let engine = setup_scru128_test_env();
let test_id = "03d4q1qhbiv09ovtuhokw5yxv";
let unpacked = nu_eval(
&engine,
PipelineData::empty(),
format!(".id unpack {}", test_id),
);
assert!(unpacked.as_record().is_ok());
let record = unpacked.as_record().unwrap();
assert!(record.get("ts_ms").is_some());
assert!(record.get("when").is_some());
assert!(record.get("counter_hi").is_some());
assert!(record.get("counter_lo").is_some());
assert!(record.get("node").is_some());
assert!(record.get("ts_ms").unwrap().as_int().is_ok());
assert!(record.get("when").unwrap().as_date().is_ok());
}
#[test]
fn test_scru128_unpack_when_matches_ts_ms() {
let engine = setup_scru128_test_env();
let test_id = "03d4q1qhbiv09ovtuhokw5yxv";
let unpacked = nu_eval(
&engine,
PipelineData::empty(),
format!(".id unpack {}", test_id),
);
let record = unpacked.as_record().unwrap();
let ts_ms = record.get("ts_ms").unwrap().as_int().unwrap();
let when = record.get("when").unwrap().as_date().unwrap();
assert_eq!(ts_ms, when.timestamp_millis());
}
#[test]
fn test_scru128_unpack_pipeline() {
let engine = setup_scru128_test_env();
let test_id = "03d4q1qhbiv09ovtuhokw5yxv";
let unpacked = nu_eval(
&engine,
PipelineData::empty(),
format!("\"{}\" | .id unpack", test_id),
);
assert!(unpacked.as_record().is_ok());
let record = unpacked.as_record().unwrap();
assert!(record.get("ts_ms").unwrap().as_int().is_ok());
assert!(record.get("when").unwrap().as_date().is_ok());
assert!(record.get("counter_hi").is_some());
assert!(record.get("counter_lo").is_some());
assert!(record.get("node").is_some());
}
#[test]
fn test_scru128_pack() {
let engine = setup_scru128_test_env();
let components =
r#"{ts_ms: 1700000000000, counter_hi: 1234, counter_lo: 5678, node: "abcd1234"}"#;
let packed = nu_eval(
&engine,
PipelineData::empty(),
format!(".id pack {}", components),
);
let id_string = packed.as_str().unwrap();
assert!(id_string.len() > 20); assert!(scru128::Scru128Id::from_str(id_string).is_ok()); }
#[test]
fn test_scru128_pack_pipeline() {
let engine = setup_scru128_test_env();
let components = r#"{ts_ms: 1700000000000, when: (date now), counter_hi: 1234, counter_lo: 5678, node: "abcd1234"}"#;
let packed = nu_eval(
&engine,
PipelineData::empty(),
format!("{} | .id pack", components),
);
let id_string = packed.as_str().unwrap();
assert!(id_string.len() > 20); assert!(scru128::Scru128Id::from_str(id_string).is_ok()); }
fn assert_id_roundtrips(engine: &crate::nu::Engine, id: &str) {
let unpacked = nu_eval(
engine,
PipelineData::empty(),
format!("\"{}\" | .id unpack", id),
);
let repacked = nu_eval(engine, PipelineData::Value(unpacked, None), ".id pack");
assert_eq!(
id,
repacked.as_str().unwrap(),
"roundtrip mismatch for {id}"
);
}
#[test]
fn test_scru128_round_trip() {
let engine = setup_scru128_test_env();
for id in [
"03gmmrhqljv8bnulus79wipck",
"03gmmrhqzjzlbz75e1r8fyvmt",
"03gmmrhsh0x17va0knqvbhly6",
] {
assert_id_roundtrips(&engine, id);
}
for _ in 0..2000 {
let id = nu_eval(&engine, PipelineData::empty(), ".id");
assert_id_roundtrips(&engine, id.as_str().unwrap());
}
}
#[test]
fn test_scru128_unpack_argument_form_parses_as_a_record() {
let engine = setup_scru128_test_env();
let id = nu_eval(&engine, PipelineData::empty(), ".id");
let id = id.as_str().unwrap();
let ts = nu_eval(
&engine,
PipelineData::empty(),
format!("let id = \"{id}\"; .id unpack $id | get ts_ms"),
);
assert!(ts.as_int().is_ok(), "ts_ms was {ts:?}");
let packed = nu_eval(
&engine,
PipelineData::empty(),
format!("let r = (\"{id}\" | .id unpack); .id pack $r"),
);
assert_eq!(packed.as_str().unwrap(), id);
}
#[test]
fn test_scru128_invalid_id() {
let engine = setup_scru128_test_env();
let engine_clone = engine.clone();
let result = std::thread::spawn(move || {
engine_clone.eval(PipelineData::empty(), ".id unpack invalid_id".to_string())
})
.join();
assert!(result.is_ok());
assert!(result.unwrap().is_err());
}
#[test]
fn test_last_command_with_timestamp() -> Result<(), Error> {
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::last_command::LastCommand::new(
store.clone(),
))])
.unwrap();
let frame = store
.append(
Frame::builder("topic")
.hash(store.cas_insert_sync("content")?)
.build(),
)
.unwrap();
let result = nu_eval(&engine, PipelineData::empty(), ".last topic");
assert!(result.get_data_by_key("timestamp").is_none());
let result = nu_eval(
&engine,
PipelineData::empty(),
".last topic --with-timestamp",
);
let timestamp = result.get_data_by_key("timestamp");
assert!(timestamp.is_some());
assert!(timestamp.unwrap().as_date().is_ok());
assert_eq!(
result.get_data_by_key("id").unwrap().as_str().unwrap(),
frame.id.to_string()
);
Ok(())
}
#[test]
fn test_eval_closure_no_job_does_not_grow_jobs_table() {
let (_store, mut engine) = setup_test_env();
let closure = engine.parse_closure("{|x, state| $x}").unwrap();
engine.attach_background_job("test-actor");
let baseline = engine.state.jobs.lock().unwrap().iter().count();
assert_eq!(baseline, 1);
for i in 0..100 {
let result = engine
.eval_closure_no_job(
&closure,
vec![
Value::int(i, Span::test_data()),
Value::nothing(Span::test_data()),
],
None,
)
.unwrap()
.into_value(Span::test_data())
.unwrap();
assert_eq!(result, Value::int(i, Span::test_data()));
}
let after = engine.state.jobs.lock().unwrap().iter().count();
assert_eq!(after, baseline);
}
#[cfg(target_os = "linux")]
fn open_fd_count() -> usize {
std::fs::read_dir("/proc/self/fd")
.expect("read /proc/self/fd")
.count()
}
#[test]
fn test_cat_follow_stops_when_interrupted() {
use crate::nu::commands;
use nu_protocol::Signals;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::cat_command::CatCommand::new(
store.clone(),
))])
.unwrap();
let flag = Arc::new(AtomicBool::new(false));
engine.state.set_signals(Signals::new(flag.clone()));
let (done_tx, done_rx) = std::sync::mpsc::channel();
let engine_clone = engine.clone();
std::thread::spawn(move || {
let out = engine_clone.eval(PipelineData::empty(), ".cat -f -T idle".to_string());
let drained = out.map(|d| d.into_iter().count());
let _ = done_tx.send(drained.is_ok());
});
std::thread::sleep(Duration::from_millis(200));
flag.store(true, Ordering::SeqCst);
let finished = done_rx.recv_timeout(Duration::from_secs(5));
assert!(
finished.is_ok(),
"a following read ignored its interrupt and stayed parked",
);
}
#[test]
fn test_last_follow_stops_when_interrupted() {
use crate::nu::commands;
use nu_protocol::Signals;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![Box::new(commands::last_command::LastCommand::new(
store.clone(),
))])
.unwrap();
let flag = Arc::new(AtomicBool::new(false));
engine.state.set_signals(Signals::new(flag.clone()));
let (done_tx, done_rx) = std::sync::mpsc::channel();
let engine_clone = engine.clone();
std::thread::spawn(move || {
let out = engine_clone.eval(PipelineData::empty(), ".last idle -f".to_string());
let _ = done_tx.send(out.map(|d| d.into_iter().count()));
});
std::thread::sleep(Duration::from_millis(200));
flag.store(true, Ordering::SeqCst);
let finished = done_rx
.recv_timeout(Duration::from_secs(5))
.expect("a following read ignored its interrupt and stayed parked");
assert!(finished.is_ok(), ".last -f failed to run: {finished:?}");
}
#[cfg(target_os = "linux")]
#[test]
fn test_cat_stream_fd_leak() {
let exe = std::env::current_exe().expect("current_exe");
let output = std::process::Command::new(exe)
.args([
"--exact",
"--ignored",
"--nocapture",
"--test-threads=1",
"nu::test_commands::tests::fd_leak_worker",
])
.output()
.expect("spawn isolated fd-leak worker");
assert!(
output.status.success(),
"isolated fd-leak worker failed:\n--- stdout ---\n{}\n--- stderr ---\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
}
#[cfg(target_os = "linux")]
#[test]
#[ignore = "spawned in isolation by test_cat_stream_fd_leak"]
fn fd_leak_worker() {
use crate::nu::commands;
use crate::store::TTL;
let (store, mut engine) = setup_test_env();
engine
.add_commands(vec![
Box::new(commands::cat_command::CatCommand::new(store.clone())),
Box::new(commands::append_command::AppendCommand::new(store.clone())),
])
.unwrap();
store
.append(Frame::builder("seed").ttl(TTL::Forever).build())
.unwrap();
let warmup = 3usize;
let iterations = 50usize;
let run_once = |engine: &Engine| {
let engine = engine.clone();
std::thread::spawn(move || {
let pipeline = engine
.eval(PipelineData::empty(), ".cat --follow".to_string())
.unwrap();
let mut iter = pipeline.into_iter();
let first = iter.next();
assert!(first.is_some(), "expected the seeded historical frame");
})
.join()
.unwrap();
};
for _ in 0..warmup {
run_once(&engine);
}
std::thread::sleep(std::time::Duration::from_millis(100));
let before = open_fd_count();
for _ in 0..iterations {
run_once(&engine);
}
std::thread::sleep(std::time::Duration::from_millis(500));
let after = open_fd_count();
let growth = after.saturating_sub(before);
eprintln!(
"fd count before={before} after={after} growth={growth} over {iterations} iterations"
);
let slack = 8;
assert!(
growth <= slack,
"file descriptor leak: fd count grew by {growth} over {iterations} \
`.cat --follow` runs (before={before}, after={after}); expected <= \
{slack}. A leaked runtime holds a socket + eventfd pair (pre-L1 mechanism)."
);
}
}