use super::*;
#[test]
fn suspicious_settings_are_reported_as_warnings() {
let clean = valid_base();
let warnings = clean.warnings();
assert!(warnings.is_empty(), "got: {warnings:?}");
let mut secure = valid_base();
secure.cookies.secure = CookieSecure::Always;
assert!(
secure.warnings().is_empty(),
"`always` is an explicit answer: {:?}",
secure.warnings()
);
let mut tls = valid_base();
tls.tls.enabled = true;
assert!(
!tls.warnings().iter().any(|w| w.contains("Secure")),
"TLS on satisfies `auto`: {:?}",
tls.warnings()
);
let mut dev = valid_base();
dev.dev_mode = true;
assert!(dev.warnings().is_empty(), "got: {:?}", dev.warnings());
assert_eq!(dev.cookie_insecure_warning(), None);
for (secure, tls, want_boot, want_issuance) in [
(CookieSecure::Auto, true, false, false),
(CookieSecure::Auto, false, false, true),
(CookieSecure::Always, true, false, false),
(CookieSecure::Always, false, false, false),
(CookieSecure::Never, true, true, false),
(CookieSecure::Never, false, false, false),
] {
let mut cfg = valid_base();
cfg.cookies.secure = secure;
cfg.tls.enabled = tls;
let warned = cfg
.warnings()
.iter()
.any(|w| w.contains("without the `Secure` attribute"));
assert_eq!(
warned, want_boot,
"[cookies] secure = {secure:?} with [tls] enabled = {tls}"
);
assert_eq!(
cfg.cookie_insecure_warning().is_some(),
want_issuance,
"[cookies] secure = {secure:?} with [tls] enabled = {tls}"
);
}
let mut cfg = valid_base();
cfg.lua.exec_timeout_ms = 5_000;
cfg.limits.pool_wait_ms = 4_000;
cfg.limits.body_read_ms = 9_000;
let warnings = cfg.warnings();
assert!(
warnings.iter().any(|w| w.contains("body_read_ms")),
"the body-read/exec-budget warning must survive the move: {warnings:?}"
);
cfg.validate().expect("a warning is never a refusal");
}
#[test]
fn the_debug_library_is_refused_by_name() {
let mut lua = LuaConfig::default();
lua.stdlib.push("debug".into());
let err = lua
.parse_stdlib()
.expect_err("`debug` must not map to a StdLib flag");
let msg = err.to_string();
assert!(
msg.contains("[lua] stdlib") && msg.contains("debug"),
"the refusal must name the setting and the library: {msg}"
);
}
fn upload_base(label: &str) -> (Config, PathBuf, PathBuf) {
let base = std::env::temp_dir().join(format!("nitr-up-{label}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
let scripts = base.join("scripts");
let uploads = base.join("uploads");
std::fs::create_dir_all(&scripts).expect("mkdir scripts");
std::fs::create_dir_all(&uploads).expect("mkdir uploads");
std::fs::write(scripts.join("app.lua"), "-- test handler").expect("write handler");
let cfg = Config {
handler_script: scripts.join("app.lua"),
..Config::default()
};
(cfg, base, uploads)
}
#[test]
fn the_upload_directory_is_validated_at_startup() {
let (mut cfg, base, uploads) = upload_base("validated");
cfg.multipart.upload_dir = Some(uploads.clone());
cfg.validate().expect("a writable upload dir validates");
cfg.multipart.upload_dir = Some(base.join("nope"));
let err = cfg.validate().expect_err("a missing upload dir");
let msg = err.to_string();
assert!(msg.contains("[multipart] upload_dir"), "got: {msg}");
assert!(msg.contains("does not exist"), "got: {msg}");
cfg.multipart.upload_dir = Some(cfg.handler_script.clone());
let err = cfg.validate().expect_err("a file, not a directory");
assert!(
err.to_string().contains("must be a directory"),
"got: {err}"
);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt as _;
let locked = base.join("locked");
std::fs::create_dir_all(&locked).expect("mkdir locked");
std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o500)).expect("chmod");
cfg.multipart.upload_dir = Some(locked.clone());
if std::fs::File::create(locked.join(".probe")).is_err() {
let err = cfg.validate().expect_err("an unwritable upload dir");
let msg = err.to_string();
assert!(msg.contains("[multipart] upload_dir"), "got: {msg}");
assert!(msg.contains("cannot be written to"), "got: {msg}");
}
let _ = std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o700));
}
let _ = std::fs::remove_dir_all(&base);
}
#[test]
fn an_upload_directory_inside_the_require_root_refuses_to_boot() {
let (mut cfg, base, _) = upload_base("rce-chain");
let inside = base.join("scripts").join("uploads");
std::fs::create_dir_all(&inside).expect("mkdir");
cfg.multipart.upload_dir = Some(inside);
let err = cfg
.validate()
.expect_err("an upload dir inside package_dir");
let msg = err.to_string();
assert!(msg.contains("[multipart] upload_dir"), "got: {msg}");
assert!(
msg.contains("loadable Lua module"),
"the refusal must say why it matters: {msg}"
);
let _ = std::fs::remove_dir_all(&base);
}
#[test]
fn a_bare_handler_script_still_refuses_an_upload_dir_beside_it() {
let base = std::env::temp_dir().join(format!("nitr-up-bare-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
std::fs::create_dir_all(base.join("uploads")).expect("mkdir uploads");
std::fs::write(base.join("app.lua"), "-- handler").expect("write handler");
let previous = std::env::current_dir().expect("cwd");
std::env::set_current_dir(&base).expect("chdir");
let cfg = Config {
handler_script: PathBuf::from("app.lua"),
multipart: MultipartConfig {
upload_dir: Some(PathBuf::from("uploads")),
},
..Config::default()
};
let result = cfg.validate();
std::env::set_current_dir(&previous).expect("restore cwd");
let _ = std::fs::remove_dir_all(&base);
let err = result.expect_err("a bare handler name must not skip the check");
assert!(
err.to_string().contains("loadable Lua module"),
"got: {err}"
);
}
#[test]
fn the_require_root_is_derived_identically_everywhere() {
for (script, expected) in [
("app.lua", "."),
("./app.lua", "."),
("scripts/app.lua", "scripts"),
("/srv/app/scripts/app.lua", "/srv/app/scripts"),
] {
let cfg = Config {
handler_script: PathBuf::from(script),
..Config::default()
};
assert_eq!(
cfg.package_dir(),
Path::new(expected),
"package_dir for {script}"
);
let opts = cfg.runtime_opts().expect("runtime opts");
assert_eq!(
opts.package_dir.as_deref(),
Some(Path::new(expected)),
"runtime_opts must pin `require` to the same root for {script}"
);
}
}
#[test]
fn an_upload_directory_inside_the_static_root_only_warns() {
let (mut cfg, base, _) = upload_base("static-overlap");
let public = base.join("public");
let uploads = public.join("uploads");
std::fs::create_dir_all(&uploads).expect("mkdir");
cfg.static_files.dir = Some(public);
cfg.multipart.upload_dir = Some(uploads);
let warnings = cfg.warnings();
assert!(
warnings.iter().any(|w| w.contains("served back over HTTP")),
"the overlap must be reported: {warnings:?}"
);
cfg.validate().expect("a warning is never a refusal");
let _ = std::fs::remove_dir_all(&base);
}
#[test]
fn the_multipart_section_parses_without_the_multipart_feature() {
let toml = r#"
handler_script = "app.lua"
[multipart]
upload_dir = "uploads"
"#;
let cfg: Config = toml::from_str(toml).expect("[multipart] must always parse");
assert_eq!(
cfg.multipart.upload_dir,
Some(PathBuf::from("uploads")),
"the value must survive the parse, not just the section"
);
}
#[test]
fn stream_slots_for_every_state_warn() {
for (workers, max_streams) in [(1, None), (1, Some(1)), (4, Some(4))] {
let mut cfg = valid_base();
cfg.workers = workers;
cfg.max_streams = max_streams;
assert!(
cfg.streams_warning().is_some(),
"workers = {workers}, max_streams = {max_streams:?}"
);
}
let mut cfg = valid_base();
cfg.workers = 4;
assert_eq!(
cfg.streams_warning(),
None,
"the default keeps a state free"
);
}
#[test]
fn response_headers_are_validated_at_startup() {
let mut cfg = valid_base();
cfg.headers.insert("X-Frame-Options".into(), "DENY".into());
cfg.validate().expect("a plain header");
for (name, value) in [("bad name", "x"), ("X-Ok", "line\nbreak")] {
let mut cfg = valid_base();
cfg.headers.insert(name.into(), value.into());
let err = cfg.validate().expect_err(name).to_string();
assert!(err.contains("[headers]") && err.contains(name), "{err}");
}
}
#[test]
fn private_hosts_are_host_names() {
let mut cfg = valid_base();
cfg.fetch.private_hosts = vec!["payments".into(), "db.internal".into()];
cfg.validate().expect("host names");
for bad in ["http://payments", "payments/charges", ""] {
let mut cfg = valid_base();
cfg.fetch.private_hosts = vec![bad.into()];
let err = cfg.validate().expect_err(bad).to_string();
assert!(err.contains("[fetch] private_hosts"), "{bad}: {err}");
}
}
#[test]
fn proxy_settings_have_environment_overrides() {
let mut cfg = valid_base();
cfg.apply_env_with(&|name| match name {
"NITR_COOKIES_SECURE" => Some("always".into()),
"NITR_TRUST_REQUEST_ID" => Some("true".into()),
"NITR_RATE_LIMIT_TRUST_FORWARDED_FOR" => Some("true".into()),
_ => None,
})
.expect("apply");
assert_eq!(cfg.cookies.secure, CookieSecure::Always);
assert!(cfg.trust_request_id);
assert!(cfg.rate_limit.trust_forwarded_for);
let mut cfg = valid_base();
let err = cfg
.apply_env_with(&|name| (name == "NITR_COOKIES_SECURE").then(|| "maybe".to_string()))
.expect_err("not a policy")
.to_string();
assert!(err.contains("NITR_COOKIES_SECURE"), "{err}");
}
#[test]
fn contradictions_are_startup_errors() {
let ok = valid_base();
ok.validate().expect("a sane config validates");
let mut cfg = valid_base();
cfg.workers = 2;
cfg.max_streams = Some(5);
let err = cfg.validate().expect_err("max_streams > workers");
assert!(err.to_string().contains("max_streams"), "got: {err}");
let mut cfg = valid_base();
cfg.lua.memory_limit = 0;
let err = cfg.validate().expect_err("memory_limit = 0");
assert!(err.to_string().contains("[lua] memory_limit"), "got: {err}");
let mut cfg = valid_base();
cfg.limits.max_header_bytes = 16 * 1024;
cfg.limits.max_uri_bytes = 16 * 1024;
let err = cfg
.validate()
.expect_err("max_uri_bytes >= max_header_bytes");
assert!(
err.to_string().contains("[limits] max_uri_bytes"),
"got: {err}"
);
for (requests, window) in [(0, 60), (100, 0)] {
let mut cfg = valid_base();
cfg.rate_limit.enabled = true;
cfg.rate_limit.requests = requests;
cfg.rate_limit.window = window;
let err = cfg.validate().expect_err("rate limit of zero");
assert!(err.to_string().contains("[rate_limit]"), "got: {err}");
}
for origin in [
"https://app.example/",
"https://app.example/app",
"app.example",
] {
let mut cfg = valid_base();
cfg.cors.origins = Some(vec![origin.into()]);
let err = cfg.validate().expect_err(origin);
assert!(
err.to_string().contains("[cors] origins"),
"{origin}: {err}"
);
}
let mut cfg = valid_base();
cfg.cors.origins = Some(vec!["https://app.example:8443".into(), "*".into()]);
cfg.validate().expect("well-formed origins");
let mut cfg = valid_base();
cfg.max_streams = Some(0);
let err = cfg.validate().expect_err("max_streams = 0");
assert!(err.to_string().contains("max_streams = 0"), "got: {err}");
let mut cfg = valid_base();
cfg.limits.pool_wait_ms = 60_000;
cfg.lua.exec_timeout_ms = 5_000;
let err = cfg.validate().expect_err("pool_wait > exec budget");
assert!(err.to_string().contains("pool_wait_ms"), "got: {err}");
let mut cfg = valid_base();
cfg.health.readiness = cfg.health.liveness.clone();
let err = cfg.validate().expect_err("identical probe paths");
assert!(err.to_string().contains("liveness"), "got: {err}");
let mut cfg = valid_base();
cfg.health.liveness = "healthz".into();
let err = cfg.validate().expect_err("path without slash");
assert!(err.to_string().contains("must start with"), "got: {err}");
let mut cfg = valid_base();
cfg.health.enabled = false;
cfg.health.liveness = "not-a-path".into();
cfg.validate().expect("disabled health is not validated");
}
#[test]
fn unknown_compression_algorithms_are_startup_errors() {
let mut cfg = valid_base();
cfg.compression.algorithms = vec!["br".into(), "zstd".into()];
let err = cfg.validate().expect_err("unknown algorithm");
let msg = err.to_string();
assert!(msg.contains("zstd"), "got: {msg}");
assert!(msg.contains("[compression]"), "got: {msg}");
let mut cfg = valid_base();
cfg.compression.algorithms = vec!["gzip".into(), "br".into()];
cfg.validate().expect("br and gzip are the supported set");
}
#[test]
fn unknown_lua_stdlib_names_are_startup_errors() {
let mut lua = LuaConfig::default();
lua.stdlib.push("iio".into());
let err = lua.parse_stdlib().expect_err("unknown stdlib name");
assert!(err.to_string().contains("`iio`"), "got: {err}");
let all = LuaConfig {
stdlib: [
"coroutine",
"table",
"io",
"os",
"string",
"utf8",
"math",
"package",
]
.map(String::from)
.to_vec(),
..LuaConfig::default()
};
let libs = all.parse_stdlib().expect("all loadable names");
assert!(libs.contains(mlua::StdLib::IO));
assert!(libs.contains(mlua::StdLib::PACKAGE));
}
#[test]
fn missing_paths_are_named_at_startup() {
let mut cfg = valid_base();
cfg.handler_script = PathBuf::from("/nonexistent/app.lua");
let err = cfg.validate().expect_err("missing handler");
assert!(err.to_string().contains("handler_script"), "got: {err}");
let mut cfg = valid_base();
cfg.templating.dir = Some(PathBuf::from("/nonexistent/templates"));
let err = cfg.validate().expect_err("missing templates");
assert!(err.to_string().contains("[templating] dir"), "got: {err}");
let mut cfg = valid_base();
cfg.templating.dir = Some(cfg.handler_script.clone());
let err = cfg.validate().expect_err("file as the templating dir");
assert!(err.to_string().contains("directory"), "got: {err}");
let mut cfg = valid_base();
cfg.database = Some(DatabaseConfig::new("/nonexistent/dir/app.db"));
let err = cfg.validate().expect_err("missing db dir");
assert!(err.to_string().contains("database directory"), "got: {err}");
}
#[test]
fn unknown_keys_are_rejected_not_ignored() {
let path = write_temp_config("typo.toml", "max_body_byte = 1\n");
let err = Config::from_file(&path).expect_err("unknown key");
assert!(err.to_string().contains("max_body_byte"), "got: {err}");
let path = write_temp_config("typo2.toml", "[limits]\nmax_body_byte = 1\n");
let err = Config::from_file(&path).expect_err("unknown section key");
assert!(err.to_string().contains("max_body_byte"), "got: {err}");
std::fs::remove_file(&path).ok();
}
proptest::proptest! {
#[test]
fn prop_limit_validation_is_total_and_names_the_setting(
workers in 1usize..8,
max_streams in proptest::option::of(0usize..8),
pool_wait_ms in 0u64..100_000,
exec_timeout_ms in 0u64..100_000,
body_read_ms in 0u64..100_000,
header_read_ms in 0u64..100_000,
) {
let mut cfg = valid_base();
cfg.workers = workers;
cfg.max_streams = max_streams;
cfg.limits.pool_wait_ms = pool_wait_ms;
cfg.limits.body_read_ms = body_read_ms;
cfg.limits.header_read_ms = header_read_ms;
cfg.lua.exec_timeout_ms = exec_timeout_ms;
match cfg.validate() {
Ok(()) => {
proptest::prop_assert!(
!(pool_wait_ms > exec_timeout_ms
&& pool_wait_ms != 0
&& exec_timeout_ms != 0),
"the pool-wait contradiction must refuse"
);
}
Err(err) => {
let msg = err.to_string();
proptest::prop_assert!(
msg.contains("pool_wait_ms") || msg.contains("max_streams"),
"a refusal must name the offending setting: {msg}"
);
}
}
}
}
#[test]
fn a_proxy_without_an_allow_list_is_refused_when_fetch_is_enabled() {
let mut cfg = valid_base();
cfg.std.features = Some(vec!["fetch".into()]);
cfg.fetch.proxy = Some("http://proxy.internal:3128".into());
let err = cfg.validate().expect_err("proxy without an allow-list");
assert!(err.to_string().contains("allowed_hosts"), "got: {err}");
cfg.fetch.allowed_hosts = Some(vec!["api.example".into()]);
cfg.validate().expect("an allow-list satisfies the rule");
cfg.fetch.allowed_hosts = None;
cfg.fetch.allow_private_networks = true;
cfg.validate()
.expect("an explicit trust decision satisfies the rule");
cfg.fetch.allow_private_networks = false;
cfg.std.features = None;
cfg.validate().expect("no fetch, no rule");
}