#![cfg(unix)]
mod common;
use std::path::Path;
use std::process::{Command, Output};
use std::time::{Duration, Instant};
fn tempdir(name: &str) -> common::TempDir {
common::tempdir("htl-cli-std-io", name)
}
fn write(path: &Path, text: &str) {
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, text).unwrap();
}
fn htl(args: &[&str], cwd: &Path) -> (bool, String, String) {
let out: Output = Command::new(common::htl_bin())
.args(args)
.current_dir(cwd)
.output()
.unwrap();
(
out.status.success(),
String::from_utf8_lossy(&out.stdout).into_owned(),
String::from_utf8_lossy(&out.stderr).into_owned(),
)
}
fn project(name: &str) -> common::TempDir {
let root = tempdir(name);
write(&root.join("htl.toml"), "[lang]\nasync = true\n");
root
}
const SELECT_PROGRAM: &str = "\
local proc = require(\"std.proc\")
local task = require(\"htl.task\")
async local t = proc.run({\"sh\", \"-c\", \"sleep 0.3; echo late\"})
local timer = task.after(100)
local first = await task.select({
timer:on(function(): string
return \"timer\"
end),
t:on(function(_ok: boolean, _exit: proc.Exit): string
return \"late\"
end),
})
print(first)
local exit = await t
io.write(exit.stdout)
";
#[test]
fn check_accepts_awaited_fs_and_proc_calls() {
let root = project("accepts");
write(
&root.join("src/main.tl"),
"local fs = require(\"std.fs\")\n\
local proc = require(\"std.proc\")\n\
\n\
local async function main(): string, integer\n \
local text = await fs.read(\"input.txt\")\n \
local exit = await proc.run({\"true\"})\n \
return text, exit.code\n\
end\n\
\n\
local text, code = await main()\n\
print(text, code)\n",
);
let (ok, _, err) = htl(&["check", "src", "--no-cache"], &root);
assert!(ok, "{err}");
assert!(err.contains("0 error(s), 0 warning(s), 0 lint(s)"), "{err}");
}
#[test]
fn check_reports_await_missing_at_the_exact_position_when_await_is_dropped_from_fs_read() {
let root = project("missing-await");
write(
&root.join("src/main.tl"),
"local fs = require(\"std.fs\")\n\
local proc = require(\"std.proc\")\n\
\n\
local async function main(): string, integer\n \
local text = fs.read(\"input.txt\")\n \
local exit = await proc.run({\"true\"})\n \
return text, exit.code\n\
end\n\
\n\
local text, code = await main()\n\
print(text, code)\n",
);
let (ok, _, err) = htl(&["check", "src", "--no-cache"], &root);
assert!(!ok, "{err}");
assert!(
err.contains(
"src/main.tl:5:17: call of an async function without await: fs.read may suspend; \
write await fs.read(..) so the suspension is visible where it happens \
[htl await-missing]"
),
"{err}"
);
}
#[test]
fn run_select_takes_the_timer_first_then_awaits_the_tasks_stdout() {
let root = project("select");
write(&root.join("src/main.tl"), SELECT_PROGRAM);
let (ok, out, err) = htl(&["run", "src/main.tl"], &root);
assert!(ok, "{err}");
assert_eq!(out, "timer\nlate\n", "{err}");
}
#[test]
fn a_cancelled_run_through_select_exits_quickly_and_the_child_does_not_outlive_it() {
let root = project("cancel-select");
write(
&root.join("src/main.tl"),
"local proc = require(\"std.proc\")\n\
local task = require(\"htl.task\")\n\
\n\
async local t = proc.run({\"sleep\", \"30.0003\"})\n\
local timer = task.after(100)\n\
local first = await task.select({\n \
timer:on(function(): string\n \
return \"timer\"\n \
end),\n \
t:on(function(_ok: boolean, _exit: proc.Exit): string\n \
return \"late\"\n \
end),\n\
})\n\
print(first)\n",
);
let t0 = Instant::now();
let (ok, out, err) = htl(&["run", "src/main.tl"], &root);
let took = t0.elapsed();
assert!(ok, "{err}");
assert_eq!(out, "timer\n", "{err}");
assert!(took < Duration::from_secs(2), "took {took:?}: {err}");
assert_gone_within("^sleep 30\\.0003$", Duration::from_secs(2));
}
#[test]
fn a_plain_cancelled_run_exits_quickly_and_the_child_does_not_outlive_it() {
let root = project("cancel");
write(
&root.join("src/main.tl"),
"local proc = require(\"std.proc\")\n\
local task = require(\"htl.task\")\n\
\n\
async local sleeper = proc.run({\"sleep\", \"30.0004\"})\n\
await task.after(100):wait()\n",
);
let t0 = Instant::now();
let (ok, _, err) = htl(&["run", "src/main.tl"], &root);
let took = t0.elapsed();
assert!(ok, "{err}");
assert!(took < Duration::from_secs(2), "took {took:?}: {err}");
assert_gone_within("^sleep 30\\.0004$", Duration::from_secs(2));
}
#[test]
fn test_round_trips_a_file_through_std_fs() {
let root = project("test");
write(
&root.join("src/fs_test.tl"),
"local t = require(\"htl.test\")\n\
local fs = require(\"std.fs\")\n\
\n\
t.describe(\"std.fs\", function()\n \
t.it(\"round trips a write and a read\", async function()\n \
local path = \"roundtrip.txt\"\n \
await fs.write(path, \"hello\")\n \
local back = await fs.read(path)\n \
t.expect(back):to_equal(\"hello\")\n \
end)\n\
end)\n",
);
let (ok, _, err) = htl(&["test", "."], &root);
assert!(ok, "{err}");
assert!(err.contains("1 passed, 0 failed"), "{err}");
}
#[test]
fn resolve_says_the_host_provides_std_fs_and_std_proc() {
let root = project("resolve");
write(&root.join("src/main.tl"), "return 0\n");
for module in ["std.fs", "std.proc"] {
let (ok, out, err) = htl(&["resolve", module], &root);
assert!(ok, "{err}");
assert!(
out.contains(&format!("htl resolve {module}: provided by the host")),
"{out}"
);
assert!(
out.contains("-htl-std-"),
"typed by the registered installer's own directory: {out}"
);
}
}
#[test]
fn build_lists_std_proc_among_the_host_provided_modules() {
let root = project("build");
write(&root.join("src/main.tl"), SELECT_PROGRAM);
let (ok, _, err) = htl(&["build", "src/main.tl", "-o", "out.hb"], &root);
assert!(ok, "{err}");
assert!(
err.contains("host must provide: htl.task, std.proc"),
"{err}"
);
}
fn assert_gone_within(pattern: &str, within: Duration) {
let deadline = Instant::now() + within;
loop {
let out = Command::new("pgrep")
.args(["-f", pattern])
.output()
.expect("pgrep");
match out.status.code() {
Some(1) => return,
Some(0) => {
if Instant::now() >= deadline {
panic!("a process matching {pattern:?} is still running after {within:?}");
}
std::thread::sleep(Duration::from_millis(50));
}
other => panic!(
"pgrep -f {pattern:?} exited {other:?}: {}",
String::from_utf8_lossy(&out.stderr)
),
}
}
}