use std::path::Path;
use std::process::Command;
mod common;
fn tempdir(name: &str) -> common::TempDir {
common::tempdir("htl-cli-pkg", 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 = Command::new(common::htl_bin())
.args(args)
.current_dir(cwd)
.env("PATH", "")
.output()
.unwrap();
(
out.status.success(),
String::from_utf8_lossy(&out.stdout).into_owned(),
String::from_utf8_lossy(&out.stderr).into_owned(),
)
}
fn git(cwd: &Path, args: &[&str]) -> String {
let out = Command::new("git")
.args([
"-c",
"user.email=htl@example.invalid",
"-c",
"user.name=htl",
])
.args(args)
.current_dir(cwd)
.output()
.expect("git on PATH");
assert!(
out.status.success(),
"git {args:?}: {}",
String::from_utf8_lossy(&out.stderr)
);
String::from_utf8_lossy(&out.stdout).trim().to_string()
}
const DECL: &str = "local record mathx\n twice: function(n: number): number\nend\nreturn mathx\n";
fn project(name: &str) -> (common::TempDir, common::TempDir) {
let dep = tempdir(&format!("{name}-remote"));
write(
&dep.join("src/mathx.tl"),
"return { twice = function(n: number): number return n * 2 end }\n",
);
write(&dep.join("types/mathx.d.tl"), DECL);
git(&dep, &["init", "-q"]);
git(&dep, &["add", "."]);
git(&dep, &["commit", "-qm", "mathx"]);
let sha = git(&dep, &["rev-parse", "HEAD"]);
let root = tempdir(name);
write(
&root.join("mlua-pkg.toml"),
&format!(
"[package]\nname = \"p\"\nversion = \"0.1.0\"\n\n\
[deps.mathx]\ngit = \"file://{}\"\nrev = \"{sha}\"\n",
dep.display()
),
);
(dep, root)
}
#[test]
fn install_runs_without_mlua_pkg_on_path_and_says_what_it_did() {
let (_dep, root) = project("install");
let (ok, _, err) = htl(&["pkg", "install"], &root);
assert!(ok, "{err}");
assert!(err.contains("install mathx"), "{err}");
assert!(err.contains("htl pkg install: 1 package(s)"), "{err}");
assert!(root.join(".htl/modules/vendored/mathx").exists(), "{err}");
assert!(
root.join("types/mathx.d.tl").is_file(),
"and what the dependency publishes is brought into the project: {err}"
);
}
#[test]
fn an_installed_dependency_is_required_at_its_entry() {
let (_dep, root) = project("entry");
write(
&root.join("src/main.tl"),
"local mathx = require(\"mathx\")\nprint(mathx.twice(21))\n",
);
write(
&root.join("tests/mathx_test.tl"),
"local t = require(\"htl.test\")\nlocal mathx = require(\"mathx\")\n\
t.it(\"doubles\", function() t.expect(mathx.twice(2)):to_equal(4) end)\n",
);
let (ok, _, err) = htl(&["pkg", "install"], &root);
assert!(ok, "{err}");
let link = root.join(".htl/modules/entries/mathx");
assert_eq!(
std::fs::read_link(&link).unwrap(),
Path::new("../vendored/mathx/src"),
"relative, through the root link, at the entry"
);
let (ok, _, err) = htl(&["check", "."], &root);
assert!(ok, "{err}");
assert!(err.contains("0 error(s)"), "{err}");
let (ok, out, err) = htl(&["run", "src/main.tl"], &root);
assert!(ok, "{err}");
assert_eq!(out.trim(), "42");
let (ok, _, err) = htl(&["test"], &root);
assert!(ok, "{err}");
assert!(err.contains("1 passed, 0 failed"), "{err}");
}
#[test]
fn a_check_cached_before_the_install_is_not_replayed_after_it() {
let (_dep, root) = project("entry-cache");
write(
&root.join("src/main.tl"),
"local mathx = require(\"mathx\")\nprint(mathx.twice(21))\n",
);
let (ok, _, err) = htl(&["check", "."], &root);
assert!(!ok, "{err}");
assert!(err.contains("module not found: 'mathx'"), "{err}");
let (ok, _, err) = htl(&["pkg", "install"], &root);
assert!(ok, "{err}");
let (ok, _, err) = htl(&["check", "."], &root);
assert!(ok, "{err}");
assert!(err.contains("0 error(s)"), "{err}");
}
#[test]
fn a_project_installed_without_entry_links_gets_them_on_the_next_check() {
let (_dep, root) = project("entry-upgrade");
write(
&root.join("src/main.tl"),
"local mathx = require(\"mathx\")\nprint(mathx.twice(21))\n",
);
let (ok, _, err) = htl(&["pkg", "install"], &root);
assert!(ok, "{err}");
std::fs::remove_dir_all(root.join(".htl/modules/entries")).unwrap();
let (ok, _, err) = htl(&["check", "."], &root);
assert!(ok, "{err}");
assert!(root.join(".htl/modules/entries/mathx").exists(), "{err}");
}
#[test]
fn clean_reports_the_cache_it_swept() {
let (_dep, root) = project("clean");
let (ok, _, err) = htl(&["pkg", "clean"], &root);
assert!(ok, "{err}");
assert!(err.contains("no lockfile"), "{err}");
htl(&["pkg", "install"], &root);
let (ok, _, err) = htl(&["pkg", "clean", "--all"], &root);
assert!(ok, "{err}");
assert!(err.contains("removed every cached package"), "{err}");
}
#[test]
fn add_writes_the_entry_and_says_what_to_run_next() {
let (_dep, root) = project("add");
let (ok, _, err) = htl(
&[
"pkg",
"add",
"vec2",
"https://example.invalid/vec2",
"--tag",
"v1.0",
],
&root,
);
assert!(ok, "{err}");
assert!(err.contains("added vec2"), "{err}");
assert!(err.contains("htl pkg install"), "{err}");
let manifest = std::fs::read_to_string(root.join("mlua-pkg.toml")).unwrap();
assert!(manifest.contains("[deps.vec2]"), "{manifest}");
}
#[test]
fn update_says_what_it_left_alone() {
let (_dep, root) = project("update");
let (ok, _, err) = htl(&["pkg", "update", "--dry-run"], &root);
assert!(ok, "{err}");
assert!(err.contains("skip mathx"), "{err}");
assert!(err.contains("dry run; nothing was written"), "{err}");
assert!(
!root.join("mlua-pkg.lock").exists(),
"and a dry run installs nothing: {err}"
);
}
#[test]
fn a_project_that_is_not_there_is_named() {
let root = tempdir("bare");
let (ok, _, err) = htl(&["pkg", "install"], &root);
assert!(!ok, "{err}");
assert!(err.contains("mlua-pkg.toml"), "{err}");
assert!(err.contains(&root.display().to_string()), "{err}");
}
#[test]
fn pkg_help_lists_the_verbs() {
let root = tempdir("help");
let (ok, out, err) = htl(&["pkg", "--help"], &root);
assert!(ok, "{err}");
for verb in ["install", "add", "update", "clean", "patch"] {
assert!(out.contains(verb), "{verb} missing from:\n{out}");
}
}
#[test]
fn add_below_the_root_writes_the_manifest_at_the_root() {
let root = tempdir("add-below-root");
write(&root.join("htl.toml"), "");
std::fs::create_dir_all(root.join("src")).unwrap();
let (ok, _, err) = htl(
&[
"pkg",
"add",
"vec2",
"https://example.invalid/vec2",
"--tag",
"v1.0",
],
&root.join("src"),
);
assert!(ok, "{err}");
assert!(root.join("mlua-pkg.toml").is_file(), "{err}");
assert!(!root.join("src/mlua-pkg.toml").exists(), "{err}");
}
#[test]
fn two_manifests_naming_two_roots_are_refused_by_check() {
let root = tempdir("two-roots");
write(
&root.join("mlua-pkg.toml"),
"[package]\nname = \"p\"\nversion = \"0.1.0\"\n",
);
write(&root.join("sub/htl.toml"), "");
write(&root.join("sub/src/a.tl"), "print(1)\n");
for args in [&["check", "sub"][..], &["test", "sub"][..]] {
let (ok, out, err) = htl(args, &root);
assert!(!ok, "{args:?}: {out}{err}");
assert!(
err.contains("name different project roots"),
"{args:?}: {err}"
);
}
}