mod common;
use common::{PAGE, Response, Server, TempDir, get, get_page, request};
use std::time::{Duration, SystemTime};
fn site(name: &str) -> TempDir {
let dir = TempDir::new(name);
dir.write("index.html", "<html>the app</html>");
dir.write("assets/app-abc123.css", "body {}");
dir
}
fn write_at(dir: &TempDir, relative: &str, contents: &str, written: SystemTime) {
dir.write(relative, contents);
std::fs::File::options()
.write(true)
.open(dir.join(relative))
.and_then(|file| file.set_modified(written))
.expect("could not set when the file was written");
}
fn check(server: &Server, address: &str, kept: &Response) -> Response {
let mut headers = vec![("Accept", PAGE)];
headers.extend(kept.header("etag").map(|tag| ("If-None-Match", tag)));
headers.extend(
kept.header("last-modified")
.map(|date| ("If-Modified-Since", date)),
);
request(server.port, "GET", address, &headers)
}
#[test]
fn a_missing_asset_is_never_answered_with_the_app() {
let dir = site("shell");
let server = Server::start(dir.path(), &["--spa", "--cache-assets"]);
let response = request(
server.port,
"GET",
"/assets/not-copied-yet-abc123.js",
&[("Accept", PAGE)],
);
assert_eq!(response.status, 404);
assert!(!response.text().contains("the app"));
assert_eq!(response.header("cache-control"), Some("no-cache"));
}
#[test]
fn a_refused_file_is_answered_like_anything_else() {
let dir = site("refused");
dir.write(".env", "API_KEY=secret");
let server = Server::start(dir.path(), &["--cache-assets"]);
let response = get(server.port, "/.env");
assert_eq!(response.status, 404);
assert_eq!(response.header("cache-control"), Some("no-cache"));
assert_eq!(response.header("x-content-type-options"), Some("nosniff"));
}
#[test]
fn a_browser_that_already_has_the_file_is_told_so() {
let dir = site("revalidate");
let server = Server::start(dir.path(), &["--cache-assets"]);
let modified = get(server.port, "/assets/app-abc123.css")
.header("last-modified")
.expect("no last-modified to test with")
.to_string();
let response = request(
server.port,
"GET",
"/assets/app-abc123.css",
&[("If-Modified-Since", &modified)],
);
assert_eq!(response.status, 304);
assert!(response.body.is_empty());
assert_eq!(
response.header("cache-control"),
Some("public, max-age=31536000, immutable")
);
}
#[test]
fn each_mode_tells_the_browser_what_it_may_keep() {
const NOTHING: &str = "no-store";
const CHECKED: &str = "no-cache";
const YEAR: &str = "public, max-age=31536000, immutable";
let dir = site("modes");
dir.write("assets/logo.png", "png");
dir.write("assets/docs/index.html", "<html>docs</html>");
let addresses = [
("/", 200),
("/assets/app-abc123.css", 200),
("/assets/logo.png", 200),
("/assets/not-copied-yet-abc123.js", 404),
("/assets/docs/", 200),
];
let assets = "files under /assets/ for a year, the rest checked each time";
let modes: [(&[&str], &str, [&str; 5], bool); 4] = [
(&[], "off", [NOTHING; 5], false),
(
&["--production"],
"on, checked for changes each time",
[CHECKED; 5],
true,
),
(
&["--cache-assets"],
assets,
[CHECKED, YEAR, YEAR, CHECKED, CHECKED],
true,
),
(
&["--production", "--cache-assets"],
assets,
[CHECKED, YEAR, YEAR, CHECKED, CHECKED],
true,
),
];
for (flags, banner, kept, tagged) in modes {
let server = Server::start(dir.path(), flags);
assert!(
server.said(&format!("Caching : {banner}")),
"{flags:?}:\n{}",
server.lines().join("\n")
);
for ((address, status), kept) in addresses.into_iter().zip(kept) {
let response = get(server.port, address);
let context = format!("{address} with {flags:?}");
assert_eq!(response.status, status, "{context}");
assert_eq!(response.header("cache-control"), Some(kept), "{context}");
assert_eq!(
response.header("etag").is_some(),
tagged && status == 200,
"{context}"
);
}
}
}
#[test]
fn production_turns_off_reload_and_lists() {
let dir = site("production");
dir.write("docs/notes.txt", "notes");
let server = Server::start(dir.path(), &["--production"]);
let page = get_page(server.port, "/?list");
assert!(page.text().contains("the app"), "{}", page.text());
assert!(!page.text().contains("tower-livereload"));
assert_eq!(get_page(server.port, "/docs/").status, 404);
assert!(server.said("Live reload : off"));
assert!(server.said("File lists : off"));
}
#[test]
fn with_production_an_unchanged_file_is_not_sent_again() {
let dir = site("production-revalidate");
let server = Server::start(dir.path(), &["--production"]);
let modified = get(server.port, "/")
.header("last-modified")
.expect("no last-modified to test with")
.to_string();
let response = request(server.port, "GET", "/", &[("If-Modified-Since", &modified)]);
assert_eq!(response.status, 304);
assert!(response.body.is_empty());
assert_eq!(response.header("cache-control"), Some("no-cache"));
}
#[test]
fn a_file_rolled_back_to_an_older_copy_is_sent_again() {
let dir = site("rollback");
let now = SystemTime::now();
write_at(&dir, "index.html", "<html>version 2</html>", now);
let server = Server::start(dir.path(), &["--production"]);
let kept = get(server.port, "/");
write_at(
&dir,
"index.html",
"<html>version 1</html>",
now - Duration::from_secs(3600),
);
let checked = check(&server, "/", &kept);
assert_eq!(checked.status, 200);
assert!(checked.text().contains("version 1"), "{}", checked.text());
let date = kept.header("last-modified").expect("no date to check with");
let by_date = request(server.port, "GET", "/", &[("If-Modified-Since", date)]);
assert_eq!(by_date.status, 200);
}
#[test]
fn a_file_changed_twice_within_a_second_is_sent_again() {
let dir = site("same-second");
let second = SystemTime::UNIX_EPOCH + Duration::from_secs(1_800_000_000);
write_at(
&dir,
"index.html",
"<html>first</html>",
second + Duration::from_millis(100),
);
let written = std::fs::metadata(dir.join("index.html")).and_then(|file| file.modified());
if written.is_ok_and(|written| written == second) {
return;
}
let server = Server::start(dir.path(), &["--production"]);
let kept = get(server.port, "/");
write_at(
&dir,
"index.html",
"<html>again</html>",
second + Duration::from_millis(600),
);
let checked = check(&server, "/", &kept);
assert_eq!(checked.status, 200);
assert!(checked.text().contains("again"), "{}", checked.text());
}
#[test]
fn a_new_file_of_the_same_size_and_time_is_sent_again() {
let dir = site("pinned-time");
let pinned = SystemTime::UNIX_EPOCH + Duration::from_secs(1_000_000_000);
write_at(&dir, "index.html", "<html>release 1.2.3</html>", pinned);
let server = Server::start(dir.path(), &["--production"]);
let kept = get(server.port, "/");
write_at(&dir, "next.html", "<html>release 1.2.4</html>", pinned);
std::fs::rename(dir.join("next.html"), dir.join("index.html"))
.expect("could not move the new page into place");
let checked = check(&server, "/", &kept);
assert_eq!(checked.status, 200);
assert!(
checked.text().contains("release 1.2.4"),
"{}",
checked.text()
);
}
#[test]
fn a_copy_named_by_its_tag_is_not_sent_again() {
let dir = site("tag");
let server = Server::start(dir.path(), &["--production"]);
let kept = get(server.port, "/assets/app-abc123.css");
let tag = kept.header("etag").expect("no tag to check with");
let checked = request(
server.port,
"GET",
"/assets/app-abc123.css",
&[("If-None-Match", tag)],
);
assert_eq!(checked.status, 304);
assert!(checked.body.is_empty());
assert_eq!(checked.header("etag"), Some(tag));
assert_eq!(checked.header("cache-control"), Some("no-cache"));
}
#[test]
fn a_file_asked_for_with_a_slash_after_it_is_not_found_even_by_its_tag() {
let dir = site("slash-after-file");
let server = Server::start(dir.path(), &["--production"]);
let kept = get(server.port, "/assets/app-abc123.css");
let tag = kept.header("etag").expect("no tag to check with");
let checked = request(
server.port,
"GET",
"/assets/app-abc123.css/",
&[("If-None-Match", tag)],
);
assert_eq!(checked.status, 404);
}
#[test]
fn a_tag_is_one_number_that_stays_when_the_server_starts_again() {
let dir = site("opaque-tag");
let tag_after_a_start = || {
let server = Server::start(dir.path(), &["--production"]);
get(server.port, "/")
.header("etag")
.expect("no tag")
.to_string()
};
let tag = tag_after_a_start();
let number = tag
.strip_prefix("W/\"")
.and_then(|rest| rest.strip_suffix('"'))
.unwrap_or_default();
assert!(
number.len() == 16 && number.chars().all(|digit| digit.is_ascii_hexdigit()),
"{tag} is not one number"
);
assert_eq!(tag_after_a_start(), tag);
}
#[test]
fn the_rest_of_a_file_that_changed_is_sent_whole() {
let dir = site("if-range");
let server = Server::start(dir.path(), &["--production"]);
let kept = get(server.port, "/assets/app-abc123.css");
let date = kept
.header("last-modified")
.expect("no date to check with")
.to_string();
let rest = [("Range", "bytes=4-"), ("If-Range", date.as_str())];
assert_eq!(
request(server.port, "GET", "/assets/app-abc123.css", &rest).status,
206
);
write_at(
&dir,
"assets/app-abc123.css",
"main { color: red }",
SystemTime::now() + Duration::from_secs(5),
);
let changed = request(server.port, "GET", "/assets/app-abc123.css", &rest);
assert_eq!(changed.status, 200);
assert_eq!(changed.text(), "main { color: red }");
}
#[test]
fn with_production_a_route_is_not_sent_the_app_again_while_it_is_unchanged() {
let dir = site("app-version");
let server = Server::start(dir.path(), &["--production", "--spa"]);
let kept = get_page(server.port, "/users/123");
assert!(kept.text().contains("the app"));
assert_eq!(check(&server, "/users/123", &kept).status, 304);
write_at(
&dir,
"index.html",
"<html>the new app</html>",
SystemTime::now() + Duration::from_secs(5),
);
let changed = check(&server, "/users/123", &kept);
assert_eq!(changed.status, 200);
assert!(changed.text().contains("the new app"));
}
#[test]
fn no_reload_leaves_the_page_alone() {
let dir = site("quiet");
let server = Server::start(dir.path(), &["--no-reload"]);
assert!(
!get_page(server.port, "/")
.text()
.contains("tower-livereload")
);
assert!(server.said("Live reload : off"));
}
#[test]
fn no_reload_stops_watching_altogether() {
let dir = site("unwatched");
let server = Server::start(dir.path(), &["--no-reload"]);
server.settle();
dir.write("index.html", "<html>edited</html>");
server.settle();
assert!(
!server.said("reloading"),
"the files were still watched:\n{}",
server.lines().join("\n")
);
}
#[test]
fn a_published_site_still_refuses_hidden_files_and_serves_its_routes() {
let dir = site("published");
dir.write(".env", "API_KEY=secret");
let server = Server::start(
dir.path(),
&[
"--spa",
"--production",
"--cache-assets",
"--host",
"0.0.0.0",
],
);
assert_eq!(get_page(server.port, "/.env").status, 404);
let route = request(server.port, "GET", "/users/123", &[("Accept", PAGE)]);
assert_eq!(route.status, 200);
assert!(route.text().contains("the app"));
assert!(!route.text().contains("tower-livereload"));
}