misterdownloadmanager: The ultimate open-source, clean-room download manager written from scratch in pure Rust for Windows, Mac, and Linux
Rust bittorrent-clientdebriddownload-acceleratordownload-managerdownloadmanagereguifile-downloadergallery-dlidmidm-alternativeinternet-download-managerm3u8-downloadermagnetplaylist-downloaderreal-debridrusttorrent-clientvideo-downloaderyoutube-downloaderyt-dlp
//! End-to-end: a real HTTP client against a running labserver.
use std::time::Duration;
use mdm_labserver::{Config, Faults, LabServer, LogEntry, content};
async fn server(faults: &str) -> LabServer {
LabServer::start(Config {
faults: Faults::parse(faults).unwrap(),
..Config::default()
})
.await
.unwrap()
}
fn expected(seed: u64, start: u64, len: usize) -> Vec<u8> {
let mut v = vec![0; len];
content::fill(seed, start, &mut v);
v
}
/// Log entries are written when a response body is dropped, which can trail the client slightly.
async fn wait_log(s: &LabServer, count: usize) -> Vec<LogEntry> {
for _ in 0..200 {
let log = s.log();
if log.len() >= count {
return log;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
panic!("expected {count} log entries, got {:?}", s.log());
}
#[tokio::test]
async fn full_get() {
let s = server("").await;
let r = reqwest::get(s.url("/gen/100K/a.bin?seed=3")).await.unwrap();
assert_eq!(r.status(), 200);
assert_eq!(r.headers()["accept-ranges"], "bytes");
assert_eq!(
r.headers()["content-disposition"],
"attachment; filename=\"a.bin\""
);
assert_eq!(r.bytes().await.unwrap(), expected(3, 0, 100 * 1024));
let log = wait_log(&s, 1).await;
assert_eq!(log[0].outcome, "complete");
assert_eq!(log[0].bytes_sent, 100 * 1024);
}
#[tokio::test]
async fn range_and_keepalive_reuse() {
let s = server("").await;
let c = reqwest::Client::new();
for (i, (a, b)) in [(10u64, 19u64), (5000, 9999)].into_iter().enumerate() {
let r = c
.get(s.url("/gen/10000"))
.header("Range", format!("bytes={a}-{b}"))
.send()
.await
.unwrap();
assert_eq!(r.status(), 206);
assert_eq!(r.headers()["content-range"], format!("bytes {a}-{b}/10000"));
assert_eq!(
r.bytes().await.unwrap(),
expected(0, a, (b - a + 1) as usize)
);
let log = wait_log(&s, i + 1).await;
assert_eq!(log[i].conn_req, i as u64 + 1, "same TCP connection reused");
}
}
#[tokio::test]
async fn head_and_416() {
let s = server("").await;
let c = reqwest::Client::new();
let r = c.head(s.url("/gen/1M")).send().await.unwrap();
assert_eq!(r.headers()["content-length"], "1048576");
let r = c
.get(s.url("/gen/100"))
.header("Range", "bytes=100-")
.send()
.await
.unwrap();
assert_eq!(r.status(), 416);
assert_eq!(r.headers()["content-range"], "bytes */100");
let log = wait_log(&s, 2).await;
assert_eq!(log[0].outcome, "head");
assert_eq!(log[1].status, 416);
}
#[tokio::test]
async fn no_range_and_if_range() {
let s = server("").await;
let c = reqwest::Client::new();
let r = c
.get(s.url("/gen/1000?no_range=true"))
.header("Range", "bytes=10-")
.send()
.await
.unwrap();
assert_eq!(r.status(), 200);
assert!(r.headers().get("accept-ranges").is_none());
// Matching If-Range -> 206; stale validator -> whole file with 200.
let etag = r.headers()["etag"].to_str().unwrap().to_owned();
let get = |v: String| {
c.get(s.url("/gen/1000"))
.header("Range", "bytes=10-")
.header("If-Range", v)
.send()
};
assert_eq!(get(etag).await.unwrap().status(), 206);
assert_eq!(get("\"stale\"".into()).await.unwrap().status(), 200);
}
#[tokio::test]
async fn etag_changes_every_n() {
let s = server("etag_change_every=2").await;
let c = reqwest::Client::new();
let mut tags = Vec::new();
for _ in 0..3 {
let r = c.head(s.url("/gen/10")).send().await.unwrap();
tags.push(r.headers()["etag"].to_str().unwrap().to_owned());
}
assert_ne!(tags[0], tags[1]);
assert_eq!(tags[1], tags[2]);
}
#[tokio::test]
async fn drop_after() {
let s = server("drop_after=10K").await;
let r = reqwest::get(s.url("/gen/1M")).await.unwrap();
assert!(r.bytes().await.is_err(), "body must fail mid-stream");
let log = wait_log(&s, 1).await;
assert_eq!(log[0].outcome, "dropped");
assert_eq!(log[0].bytes_sent, 10 * 1024);
}
#[tokio::test]
async fn a_refusal_shows_how_far_the_slots_responses_were_sent() {
// #224: the engine's test tells a reconnect the server refused because it still counted the
// response it replaces (sent up to where another connection's part begins) from a
// connection too many.
let s = server("max_conns=2&rate=200K").await;
let c = reqwest::Client::new();
let mut first = c
.get(s.url("/gen/1M"))
.header("range", "bytes=4096-")
.send()
.await
.unwrap();
assert_eq!(first.status(), 206);
let mut got = 0;
while got < 20_000 {
got += first.chunk().await.unwrap().unwrap().len() as u64;
}
let ip = "127.0.0.1".parse().unwrap();
let hold = s.hold_slot(ip);
let refused = c.get(s.url("/gen/1M")).send().await.unwrap();
assert_eq!(refused.status(), 503);
drop(hold);
drop(first);
let log = wait_log(&s, 2).await;
let r = log.iter().find(|e| e.outcome == "fault:max_conns").unwrap();
assert_eq!(r.held.len(), 2, "{:?}", r.held);
let response = r
.held
.iter()
.find(|h| h.from == 4096)
.expect("the response");
assert!(
(4096 + got..=1 << 20).contains(&response.sent_to),
"{response:?}, {got} bytes received"
);
assert!(
r.held.contains(&mdm_labserver::Held::default()),
"the test's slot"
);
// Other entries have none.
assert!(
log.iter()
.all(|e| e.outcome == "fault:max_conns" || e.held.is_empty())
);
}
#[tokio::test]
async fn max_conns_and_fail_every() {
let s = server("max_conns=1&rate=20K").await;
let c = reqwest::Client::new();
let first = c.get(s.url("/gen/1M")).send().await.unwrap(); // body in flight, slot held
let second = c.get(s.url("/gen/1M")).send().await.unwrap();
assert_eq!(first.status(), 200);
assert_eq!(second.status(), 503);
drop(first);
let log = wait_log(&s, 2).await;
assert!(log.iter().any(|e| e.outcome == "fault:max_conns"));
let s = server("fail_every=2").await;
let codes: Vec<u16> = futures::future::join_all((0..4).map(|_| async {
reqwest::get(s.url("/gen/10"))
.await
.unwrap()
.status()
.as_u16()
}))
.await;
assert_eq!(codes.iter().filter(|c| **c == 503).count(), 2);
}
#[tokio::test]
async fn rate_limit_is_respected() {
let s = server("").await;
let t = std::time::Instant::now();
let body = reqwest::get(s.url("/gen/100K?rate=200K"))
.await
.unwrap()
.bytes()
.await
.unwrap();
let secs = t.elapsed().as_secs_f64();
assert_eq!(body.len(), 100 * 1024);
assert!((0.4..1.5).contains(&secs), "100K at 200K/s took {secs:.2}s");
}
#[tokio::test]
async fn bad_query_is_rejected() {
let s = server("").await;
let r = reqwest::get(s.url("/gen/10?speed=1")).await.unwrap();
assert_eq!(r.status(), 400);
}
#[tokio::test]
async fn log_records_what_the_client_sent() {
let s = server("").await;
let c = reqwest::Client::new();
c.get(s.url("/gen/10/a.bin"))
.header("Referer", "http://example.test/page")
.header("Cookie", "sid=1")
.header("User-Agent", "lab-test/1")
.send()
.await
.unwrap()
.bytes()
.await
.unwrap();
let r = c
.post(s.url("/form/10/f.bin?seed=2"))
.header("Content-Type", "application/x-www-form-urlencoded")
.body("token=abc¬e=hi")
.send()
.await
.unwrap();
assert_eq!(r.status(), 200);
assert_eq!(r.bytes().await.unwrap(), expected(2, 0, 10));
let log = wait_log(&s, 2).await;
let get = &log[0];
assert_eq!(get.method, "GET");
assert_eq!(get.referer.as_deref(), Some("http://example.test/page"));
assert_eq!(get.cookie.as_deref(), Some("sid=1"));
assert_eq!(get.user_agent.as_deref(), Some("lab-test/1"));
assert_eq!(get.req_body_len, None);
let post = &log[1];
assert_eq!(post.method, "POST");
assert_eq!(post.path, "/form/10/f.bin");
assert_eq!(post.req_body_len, Some(17));
assert_eq!(post.req_body_head.as_deref(), Some("token=abc¬e=hi"));
assert_eq!(
post.req_content_type.as_deref(),
Some("application/x-www-form-urlencoded")
);
// SHA-256 of "abc", the well-known test vector, to pin the hash and its hex form.
let r = c
.post(s.url("/form/10?need=x%3D"))
.body("abc")
.send()
.await
.unwrap();
assert_eq!(r.status(), 403);
let log = wait_log(&s, 3).await;
assert_eq!(
log[2].req_body_sha256.as_deref(),
Some("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad")
);
assert_eq!(post.outcome, "complete");
assert!(post.req > get.req);
}
#[tokio::test]
async fn pages_are_logged_too() {
let s = server("").await;
reqwest::get(s.url("/page?link=%2Fgen%2F1K%2Fa.zip"))
.await
.unwrap();
let log = wait_log(&s, 1).await;
assert_eq!(log[0].path, "/page");
assert_eq!(log[0].status, 200);
assert!(log[0].body_len > 0);
// The redirect hop is not logged (the engine's tests read the log as the file requests).
let c = reqwest::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.build()
.unwrap();
c.get(s.url("/redirect?to=%2Fgen%2F10"))
.send()
.await
.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(s.log().len(), 1);
}
#[tokio::test]
async fn cookie_page_sets_cookies() {
let s = server("").await;
let r = reqwest::get(s.url("/cookie?set=sid=1&httponly=auth=xyz&clear=old"))
.await
.unwrap();
assert_eq!(r.status(), 200);
assert!(
r.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("text/html")
);
let set: Vec<_> = r
.headers()
.get_all("set-cookie")
.iter()
.map(|v| v.to_str().unwrap().to_owned())
.collect();
assert_eq!(
set,
[
"sid=1; Path=/",
"auth=xyz; Path=/; HttpOnly",
"old=; Path=/; Max-Age=0"
]
);
for bad in [
"/cookie",
"/cookie?set=nope",
"/cookie?set=a=b%3Bc",
"/cookie?x=1",
] {
let r = reqwest::get(s.url(bad)).await.unwrap();
assert_eq!(r.status(), 400, "{bad}");
}
}
#[tokio::test]
async fn require_cookie_and_referer() {
let s = server("").await;
let c = reqwest::Client::new();
let url = s.url("/gen/10/a.bin?require_cookie=sid=1");
assert_eq!(c.get(&url).send().await.unwrap().status(), 403);
let wrong = c.get(&url).header("Cookie", "sid=2").send().await.unwrap();
assert_eq!(wrong.status(), 403);
let ok = c
.get(&url)
.header("Cookie", "a=b; sid=1")
.send()
.await
.unwrap();
assert_eq!(ok.status(), 200);
ok.bytes().await.unwrap();
let url = s.url("/gen/10/a.bin?require_referer=http%3A%2F%2F127.0.0.1%2Fpage");
assert_eq!(c.get(&url).send().await.unwrap().status(), 403);
let ok = c
.get(&url)
.header("Referer", "http://127.0.0.1/page?x=1")
.send()
.await
.unwrap();
assert_eq!(ok.status(), 200);
ok.bytes().await.unwrap();
let log = wait_log(&s, 5).await;
let count = |o: &str| log.iter().filter(|e| e.outcome == o).count();
assert_eq!(count("fault:require_cookie"), 2);
assert_eq!(count("fault:require_referer"), 1);
// Server-wide, as --faults would set it.
let s = server("require_cookie=sid").await;
assert_eq!(reqwest::get(s.url("/gen/10")).await.unwrap().status(), 403);
}
#[tokio::test]
async fn disposition_names_and_inline_types() {
let s = server("").await;
let c = reqwest::Client::new();
let head = async |p: &str| c.head(s.url(p)).send().await.unwrap();
let r = head("/gen/10/download.php?cd=report%202026.zip").await;
assert_eq!(
r.headers()["content-disposition"],
"attachment; filename=\"report 2026.zip\""
);
assert_eq!(r.headers()["content-type"], "application/octet-stream");
let r = head("/gen/10/get?cdstar=%E6%8A%A5%E5%91%8A.zip").await;
assert_eq!(
r.headers()["content-disposition"],
"attachment; filename=\"fallback-name.zip\"; filename*=UTF-8''%E6%8A%A5%E5%91%8A.zip"
);
for (name, ty) in [
("doc.pdf", "application/pdf"),
("song.mp3", "audio/mpeg"),
("clip.mp4", "video/mp4"),
] {
let r = head(&format!("/gen/10/{name}?inline=1")).await;
assert_eq!(r.headers()["content-type"], ty);
assert_eq!(
r.headers()["content-disposition"],
format!("inline; filename=\"{name}\"")
);
let r = head(&format!("/gen/10/{name}?inline=bare")).await;
assert_eq!(r.headers()["content-type"], ty);
assert!(r.headers().get("content-disposition").is_none());
}
let r = head("/gen/10?inline=1").await;
assert_eq!(r.headers()["content-disposition"], "inline");
assert_eq!(head("/gen/10?inline=sometimes").await.status(), 400);
}
#[tokio::test]
async fn forms_answer_only_their_post() {
let s = server("").await;
let c = reqwest::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.build()
.unwrap();
let r = c.get(s.url("/form/1K/r.zip")).send().await.unwrap();
assert_eq!(r.status(), 405);
assert_eq!(r.headers()["allow"], "POST");
let post = async |path: &str, ty: &str, body: &'static str| {
c.post(s.url(path))
.header("Content-Type", ty)
.body(body)
.send()
.await
.unwrap()
};
let url = "application/x-www-form-urlencoded";
let r = post("/form/1K/r.zip?seed=5", url, "token=abc").await;
assert_eq!(r.status(), 200);
assert_eq!(
r.headers()["content-disposition"],
"attachment; filename=\"r.zip\""
);
assert_eq!(r.bytes().await.unwrap(), expected(5, 0, 1024));
assert_eq!(post("/form/1K/r.zip", url, "token=abd").await.status(), 403);
let r = post("/form/1K/r.zip?need=code%3D7", url, "code=7").await;
assert_eq!(r.status(), 200);
r.bytes().await.unwrap();
let mp = "--b0\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\nabc\r\n--b0--\r\n";
let r = post(
"/form/1K/m.zip?seed=6",
"multipart/form-data; boundary=b0",
mp,
)
.await;
assert_eq!(r.status(), 200);
assert_eq!(r.bytes().await.unwrap(), expected(6, 0, 1024));
let r = post(
"/form/1K/s.zip?seed=7&see_other=1&cd=x.zip",
url,
"token=abc",
)
.await;
assert_eq!(r.status(), 303);
assert_eq!(r.headers()["location"], "/gen/1K/s.zip?seed=7&cd=x.zip");
let log = wait_log(&s, 6).await;
let outcomes: Vec<_> = log.iter().map(|e| e.outcome.as_str()).collect();
for o in ["method", "form", "see_other"] {
assert!(outcomes.contains(&o), "{o}: {outcomes:?}");
}
}
#[tokio::test]
async fn one_time_links() {
let s = server("").await;
let c = reqwest::Client::new();
let url = s.url("/gen/1K/once.zip?once=1&seed=1");
let first = c.get(&url).send().await.unwrap();
assert_eq!(first.status(), 200);
assert_eq!(first.bytes().await.unwrap().len(), 1024);
assert_eq!(c.get(&url).send().await.unwrap().status(), 410);
assert_eq!(c.head(&url).send().await.unwrap().status(), 410);
// Another query is another link; a HEAD uses it up.
let other = s.url("/gen/1K/once.zip?once=1&seed=2");
assert_eq!(c.head(&other).send().await.unwrap().status(), 200);
assert_eq!(c.get(&other).send().await.unwrap().status(), 410);
// A refused request (no cookie) doesn't.
let gated = s.url("/gen/1K/g.zip?once=1&require_cookie=sid");
assert_eq!(c.get(&gated).send().await.unwrap().status(), 403);
let ok = c
.get(&gated)
.header("Cookie", "sid=1")
.send()
.await
.unwrap();
assert_eq!(ok.status(), 200);
ok.bytes().await.unwrap();
let log = wait_log(&s, 7).await;
assert_eq!(log.iter().filter(|e| e.outcome == "fault:once").count(), 3);
}
async fn text(s: &LabServer, path: &str) -> (reqwest::header::HeaderMap, String) {
let r = reqwest::get(s.url(path)).await.unwrap();
assert_eq!(r.status(), 200, "{path}");
(r.headers().clone(), r.text().await.unwrap())
}
#[tokio::test]
async fn page_variants() {
let s = server("").await;
let (h, page) = text(&s, "/page?video=%2Fgen%2F1M%2Fclip.mp4").await;
assert!(h.get("content-security-policy").is_none());
assert!(page.contains(
"<video id=video src=\"/gen/1M/clip.mp4\" width=640 height=360 controls></video>"
));
assert!(page.contains("href=/assets/page.css"));
assert!(!page.contains("style="), "no inline styles (csp=strict)");
let (h, page) = text(&s, "/page?csp=strict").await;
assert_eq!(
h["content-security-policy"],
"default-src 'none'; style-src 'self'; img-src 'self'; media-src 'self'; script-src 'self'"
);
assert!(page.contains("<video id=video src=\"/gen/1M/clip.mp4?inline=1\""));
let (_, page) = text(&s, "/page?muted_loop=1&w=320&h=180").await;
assert!(page.contains("width=320 height=180 muted loop autoplay playsinline></video>"));
assert!(!page.contains("controls"));
let (h, page) = text(&s, "/page?iframe=1&csp=strict&w=320&h=180").await;
assert!(page.contains("<iframe id=frame"));
assert!(page.contains("width=360 height=220"));
assert!(!page.contains("<video"));
let csp = h["content-security-policy"].to_str().unwrap();
assert!(csp.ends_with("; frame-src 'self'"));
let inner = page.split("<iframe").nth(1).unwrap();
let inner = inner.split("src=\"").nth(1).unwrap().split('"').next();
let (h, inner) = text(&s, &inner.unwrap().replace("&", "&")).await;
assert!(inner.contains("<video id=video") && inner.contains("width=320 height=180"));
assert!(h.contains_key("content-security-policy"));
let (_, page) = text(&s, "/page?shadow=1").await;
assert!(page.contains("<div id=host><template shadowrootmode=open>"));
let (_, page) = text(&s, "/page?several=2").await;
assert!(page.contains("id=video1") && page.contains("id=video2"));
assert!(page.contains("<source src=\"/gen/1M/clip2.mp4?seed=2&inline=1\""));
assert!(!page.contains("id=video "));
let (_, page) = text(&s, "/page?audio=1&link=%2Fx").await;
assert!(page.contains("<audio id=audio src=\"/gen/512K/sound.mp3?inline=1\" controls>"));
assert!(page.contains("<a id=link href=\"/x\">"));
assert!(!page.contains("<video"));
let (h, page) = text(&s, "/page?hls=1&csp=strict").await;
assert!(page.contains(
"<script src=/assets/stream.js data-manifest=\"/hls/master.m3u8\" data-player=player>"
));
let csp = h["content-security-policy"].to_str().unwrap();
assert!(csp.contains("connect-src 'self'") && csp.contains("media-src 'self' blob:"));
let (_, page) = text(&s, "/page?dash=1").await;
assert!(page.contains("data-manifest=\"/dash/manifest.mpd\""));
// Several streams: a player each, in order (#38's media list).
let (_, page) = text(&s, "/page?hls=1&dash=1&drm=1&video=1").await;
assert!(page.contains("<video id=player ") && page.contains("data-player=player>"));
assert!(
page.contains("<video id=player3 ")
&& page.contains("data-manifest=\"/dash/protected.mpd\" data-player=player3")
);
assert!(page.contains("<video id=video src=\"/gen/1M/clip.mp4?inline=1\""));
let (h, js) = text(&s, "/assets/stream.js").await;
assert!(
h["content-type"]
.to_str()
.unwrap()
.starts_with("text/javascript")
);
assert!(js.contains("fetch("));
let (h, _) = text(&s, "/assets/page.css").await;
assert!(h["content-type"].to_str().unwrap().starts_with("text/css"));
let r = reqwest::get(s.url("/assets/x.js")).await.unwrap();
assert_eq!(r.status(), 404);
}
#[tokio::test]
async fn form_page_posts_to_form() {
let s = server("").await;
let (_, page) = text(&s, "/formpage?size=2M&token=t1&with=once%3D1").await;
assert!(page.contains(
"<form id=form method=post enctype=application/x-www-form-urlencoded \
action=\"/form/2M/report.zip?seed=5&once=1\">"
));
assert!(page.contains(
"<form id=multipart method=post enctype=multipart/form-data \
action=\"/form/2M/multipart-report.zip?seed=6&once=1\">"
));
assert!(
page.contains("action=\"/form/2M/see-other-report.zip?seed=7&see_other=1&once=1\"")
);
assert!(page.contains("name=token value=\"t1\""));
assert!(page.contains("<button id=submit-multipart>"));
}
#[tokio::test]
async fn hls_and_dash() {
let s = server("").await;
let (h, master) = text(&s, "/hls/master.m3u8").await;
assert_eq!(h["content-type"], "application/vnd.apple.mpegurl");
assert!(master.starts_with("#EXTM3U\n"));
assert!(master.contains("RESOLUTION=1280x720") && master.contains("BANDWIDTH=640000"));
assert!(master.contains("#EXT-X-MEDIA:TYPE=AUDIO"));
assert!(master.contains("URI=\"audio/index.m3u8\""));
let variants: Vec<&str> = master.lines().filter(|l| !l.starts_with('#')).collect();
assert_eq!(variants, ["720p/index.m3u8", "360p/index.m3u8"]);
let mut seen = Vec::new();
for (track, len) in [("720p", 48128), ("360p", 24064), ("audio", 6016)] {
let (_, media) = text(&s, &format!("/hls/{track}/index.m3u8")).await;
assert!(media.contains("#EXT-X-ENDLIST"));
let segs: Vec<&str> = media.lines().filter(|l| !l.starts_with('#')).collect();
assert_eq!(segs, ["seg0.ts", "seg1.ts", "seg2.ts"]);
for seg in segs {
let r = reqwest::get(s.url(&format!("/hls/{track}/{seg}")))
.await
.unwrap();
assert_eq!(r.headers()["content-type"], "video/mp2t");
let b = r.bytes().await.unwrap();
assert_eq!(b.len(), len);
assert!(b.iter().step_by(188).all(|x| *x == 0x47));
assert!(!seen.contains(&b), "segments differ");
seen.push(b);
}
}
for missing in ["/hls/720p/seg3.ts", "/hls/1080p/index.m3u8"] {
let r = reqwest::get(s.url(missing)).await.unwrap();
assert_eq!(r.status(), 404, "{missing}");
}
let (h, mpd) = text(&s, "/dash/manifest.mpd").await;
assert_eq!(h["content-type"], "application/dash+xml");
assert!(mpd.contains("mediaPresentationDuration=\"PT12S\""));
assert!(mpd.contains("<Representation id=\"720p\""));
assert!(mpd.contains("<Representation id=\"audio\""));
assert!(!mpd.contains("ContentProtection"));
let (h, mpd) = text(&s, "/dash/protected.mpd").await;
assert_eq!(h["content-type"], "application/dash+xml");
assert_eq!(
mpd.matches("urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed")
.count(),
2
);
assert!(mpd.contains("<Representation id=\"720p\""));
let r = reqwest::get(s.url("/dash/720p/init.mp4")).await.unwrap();
assert_eq!(r.headers()["content-type"], "video/mp4");
assert_eq!(&r.bytes().await.unwrap()[4..8], b"ftyp");
let r = reqwest::get(s.url("/dash/audio/seg3.m4s")).await.unwrap();
assert_eq!(r.headers()["content-type"], "audio/mp4");
assert_eq!(r.bytes().await.unwrap().len(), 6016);
let r = reqwest::get(s.url("/dash/audio/seg0.m4s")).await.unwrap();
assert_eq!(r.status(), 404);
}
/// #171: the same streams with no .m3u8 or .mpd in any address, as text/plain and octet-stream,
/// and the pages that play them (a decoy text answer first).
#[tokio::test]
async fn hls_and_dash_without_their_endings_or_types() {
let s = server("").await;
let (h, master) = text(&s, "/hls2/playlist?id=x%201").await;
assert_eq!(h["content-type"], "text/plain; charset=utf-8");
assert!(master.starts_with("#EXTM3U\n") && master.contains("RESOLUTION=1280x720"));
assert!(master.contains("URI=\"playlist?id=x%201&track=audio\""));
let variants: Vec<&str> = master.lines().filter(|l| !l.starts_with('#')).collect();
assert_eq!(
variants,
[
"playlist?id=x%201&track=720p",
"playlist?id=x%201&track=360p"
]
);
assert!(!master.contains(".m3u8"));
for (track, len) in [("720p", 48128), ("audio", 6016)] {
let (h, media) = text(&s, &format!("/hls2/playlist?id=x%201&track={track}")).await;
assert_eq!(h["content-type"], "text/plain; charset=utf-8");
assert!(media.contains("#EXT-X-ENDLIST"));
let segs: Vec<&str> = media.lines().filter(|l| !l.starts_with('#')).collect();
assert_eq!(segs.len(), 3);
assert_eq!(segs[0], format!("seg?id=x%201&track={track}&i=0"));
let r = reqwest::get(s.url(&format!("/hls2/{}", segs[2])))
.await
.unwrap();
assert_eq!(r.headers()["content-type"], "application/octet-stream");
let b = r.bytes().await.unwrap();
assert_eq!(b.len(), len);
assert!(b.iter().step_by(188).all(|x| *x == 0x47));
}
for missing in [
"/hls2/playlist?id=a&track=1080p",
"/hls2/seg?track=720p&i=3",
"/hls2/seg?track=720p",
] {
let r = reqwest::get(s.url(missing)).await.unwrap();
assert_eq!(r.status(), 404, "{missing}");
}
let (h, mpd) = text(&s, "/dash2/manifest?id=lab").await;
assert_eq!(h["content-type"], "application/octet-stream");
assert!(mpd.contains("<MPD ") && mpd.contains("<Representation id=\"360p\""));
let r = reqwest::get(s.url("/dash2/720p/init.mp4")).await.unwrap();
assert_eq!(&r.bytes().await.unwrap()[4..8], b"ftyp");
let (h, config) = text(&s, "/hls2/config?id=lab").await;
assert_eq!(h["content-type"], "text/plain; charset=utf-8");
assert!(config.starts_with('{') && !config.contains("#EXTM3U"));
let (_, page) = text(&s, "/page?hls2=1&dash2=1").await;
assert!(page.contains(
"data-manifest=\"/hls2/playlist?id=lab\" data-player=player data-kind=hls \
data-decoy=\"/hls2/config?id=lab\">"
));
assert!(
page.contains(
"data-manifest=\"/dash2/manifest?id=lab\" data-player=player2 data-kind=dash"
)
);
let (_, js) = text(&s, "/assets/stream.js").await;
assert!(js.contains("dataset.kind") && js.contains("dataset.decoy"));
}
#[tokio::test]
async fn help_lists_the_routes() {
let s = server("").await;
let help = reqwest::get(s.url("/"))
.await
.unwrap()
.text()
.await
.unwrap();
for word in [
"cdstar=",
"inline=bare",
"require_cookie=",
"require_referer=",
"once=1",
"POST /form",
"/formpage",
"/cookie?set=",
"csp=strict",
"muted_loop",
"iframe=1",
"shadow=1",
"several=N",
"audio=",
"hls=1",
"/hls/master.m3u8",
"/dash/manifest.mpd",
"/dash/protected.mpd",
"drm=1",
"hls2=1",
"/hls2/playlist?id=",
"/dash2/manifest?id=",
"/hls2/config?id=",
"req_body_sha256",
"referer",
] {
assert!(help.contains(word), "{word}");
}
}
/// `stall_at` (#123): a response stops at that byte and goes on once the server's faults are
/// changed; a request that starts past it isn't held; `settled` waits for every request's entry.
#[tokio::test]
async fn a_stall_holds_a_byte_back_until_lifted() {
let s = server("stall_at=64K").await;
let mut r = reqwest::get(s.url("/gen/256K/s.bin?seed=5")).await.unwrap();
let mut got = Vec::new();
while got.len() < 64 * 1024 {
got.extend_from_slice(&r.chunk().await.unwrap().unwrap());
}
assert_eq!(got.len(), 64 * 1024, "nothing past the stall");
// Held: no byte comes while the stall stands.
let more = tokio::time::timeout(Duration::from_millis(300), r.chunk()).await;
assert!(more.is_err(), "the stall let bytes through");
// Past the stall point, a range is served at once.
let tail = reqwest::Client::new()
.get(s.url("/gen/256K/s.bin?seed=5"))
.header("Range", "bytes=131072-")
.send()
.await
.unwrap()
.bytes()
.await
.unwrap();
assert_eq!(tail, expected(5, 128 * 1024, 128 * 1024));
s.set_faults(Faults::default());
while let Some(c) = r.chunk().await.unwrap() {
got.extend_from_slice(&c);
}
assert_eq!(got, expected(5, 0, 256 * 1024));
tokio::time::timeout(Duration::from_secs(20), s.settled())
.await
.expect("every request is logged");
assert_eq!(s.log().len(), 2);
assert!(s.log().iter().all(|e| e.outcome == "complete"));
}