Files
Mateusz Gruszczyński 9e65aa0103
build / test (push) Waiting to run
0.1.17
2026-11-17 16:50:28 +01:00

917 lines
29 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! End-to-end test on the virtual adapter: scanning, channels, M3U, ACL, HLS,
//! MPEG-TS, EPG/XMLTV, sharing and recording.
use axum::body::Body;
use axum::extract::connect_info::MockConnectInfo;
use axum::http::{header, Method, Request, StatusCode};
use axum::Router;
use http_body_util::BodyExt;
use serde_json::{json, Value};
use simply_dvb::app::{AppState, Options, State};
use simply_dvb::db::Db;
use simply_dvb::ts::testgen::GenMux;
use simply_dvb::{auth, epg, recorder, web};
use std::net::SocketAddr;
use std::time::Duration;
use tower::ServiceExt;
struct Env {
state: State,
lan: Router,
wan: Router,
cookie: String,
_dir: tempfile::TempDir,
}
async fn setup() -> Env {
let _ = tracing_subscriber::fmt()
.with_env_filter("simply_dvb=debug")
.with_test_writer()
.try_init();
std::env::set_var("SIMPLY_DVB_VIRTUAL_SPEED", "4");
let dir = tempfile::tempdir().unwrap();
let mux_dir = dir.path().join("muxes");
std::fs::create_dir_all(&mux_dir).unwrap();
let t = chrono::Utc::now().timestamp();
let mut m = GenMux::sample(0x0003, 0x0451, &["TVP1 HD", "Polsat Śląsk", "TVN"], t);
m.other_muxes = vec![(0x0004, 610_000_000)];
std::fs::write(mux_dir.join("538.ts"), m.generate(40)).unwrap();
// second mux – known only from the first one's NIT (network discovery)
let m2 = GenMux::sample(0x0004, 0x0500, &["Radio Test"], t);
std::fs::write(mux_dir.join("610.ts"), m2.generate(4)).unwrap();
let db = Db::open(&dir.path().join("t.db")).await.unwrap();
db.create_user(
"admin",
&auth::hash_password("haslo-admina").unwrap(),
"admin",
)
.await
.unwrap();
db.create_user(
"widz",
&auth::hash_password("haslo-widza").unwrap(),
"viewer",
)
.await
.unwrap();
let opts = Options {
data_dir: dir.path().to_path_buf(),
dev_root: dir.path().join("brak-dvb").to_string_lossy().to_string(),
virtual_dirs: vec![mux_dir.to_string_lossy().to_string()],
stream_port: Some(9981),
htsp_port: None,
panel_port: 9980,
};
let (state, epg_rx) = AppState::new(db, opts).await.unwrap();
tokio::spawn(epg::writer_task(state.clone(), epg_rx));
tokio::spawn(recorder::scheduler_task(state.clone()));
let st = state.clone();
tokio::spawn(async move {
loop {
tokio::time::sleep(Duration::from_millis(500)).await;
st.tuners.reap();
st.hls.reap();
}
});
let lan = web::router(state.clone())
.layer(MockConnectInfo(SocketAddr::from(([192, 168, 1, 50], 5000))));
let wan =
web::router(state.clone()).layer(MockConnectInfo(SocketAddr::from(([8, 8, 8, 8], 5000))));
let mut env = Env {
state,
lan,
wan,
cookie: String::new(),
_dir: dir,
};
env.cookie = login(&env.lan, "admin", "haslo-admina").await;
env
}
async fn login(r: &Router, user: &str, pw: &str) -> String {
let res = r
.clone()
.oneshot(
Request::post("/api/login")
.header(header::CONTENT_TYPE, "application/json")
.header("x-requested-with", "simply-dvb")
.body(Body::from(
json!({"username": user, "password": pw}).to_string(),
))
.unwrap(),
)
.await
.unwrap();
assert_eq!(res.status(), StatusCode::OK);
let c = res
.headers()
.get(header::SET_COOKIE)
.unwrap()
.to_str()
.unwrap();
c.split(';').next().unwrap().to_string()
}
async fn call(
r: &Router,
method: Method,
uri: &str,
cookie: &str,
body: Option<Value>,
) -> (StatusCode, Vec<u8>) {
let mut b = Request::builder()
.method(method)
.uri(uri)
.header("x-requested-with", "simply-dvb");
if !cookie.is_empty() {
b = b.header(header::COOKIE, cookie);
}
let req = match body {
Some(v) => b
.header(header::CONTENT_TYPE, "application/json")
.body(Body::from(v.to_string()))
.unwrap(),
None => b.body(Body::empty()).unwrap(),
};
let res = r.clone().oneshot(req).await.unwrap();
let st = res.status();
let bytes = res.into_body().collect().await.unwrap().to_bytes().to_vec();
(st, bytes)
}
async fn json_of(
r: &Router,
method: Method,
uri: &str,
cookie: &str,
body: Option<Value>,
) -> Value {
let (st, b) = call(r, method, uri, cookie, body).await;
assert!(
st.is_success(),
"{uri}: {st} {}",
String::from_utf8_lossy(&b)
);
serde_json::from_slice(&b).unwrap()
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn full_flow() {
let env = setup().await;
let c = env.cookie.clone();
eprintln!("== setup ok");
// no session -> 401, missing CSRF header -> 403
let (st, _) = call(&env.lan, Method::GET, "/api/channels", "", None).await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
let res = env
.lan
.clone()
.oneshot(
Request::post("/api/scan")
.header(header::COOKIE, &c)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(res.status(), StatusCode::FORBIDDEN);
// virtual adapter
let ad = json_of(&env.lan, Method::GET, "/api/adapters", &c, None).await;
assert_eq!(ad.as_array().unwrap().len(), 1);
assert_eq!(ad[0]["device"]["bus"], "virtual");
// profile: preferences, signed-in devices, viewing statistics, PWA manifest
json_of(
&env.lan,
Method::PUT,
"/api/me/prefs",
&c,
Some(json!({"sdvb-lang": "pl_PL", "sdvb-fav": "[1,2]"})),
)
.await;
let prefs = json_of(&env.lan, Method::GET, "/api/me/prefs", &c, None).await;
assert_eq!(prefs["sdvb-fav"], "[1,2]");
let sessions = json_of(&env.lan, Method::GET, "/api/me/sessions", &c, None).await;
assert!(sessions
.as_array()
.unwrap()
.iter()
.any(|s| s["current"] == true));
let views = json_of(&env.lan, Method::GET, "/api/stats/viewing?days=7", &c, None).await;
assert_eq!(views["hours"].as_array().unwrap().len(), 24);
let (st, body) = call(&env.lan, Method::GET, "/manifest.webmanifest", "", None).await;
assert_eq!(st, StatusCode::OK);
assert!(String::from_utf8_lossy(&body).contains("standalone"));
eprintln!("== adapters ok");
// scanning
json_of(
&env.lan,
Method::POST,
"/api/scan",
&c,
Some(json!({"preset": "custom", "frequencies_mhz": [538, 546]})),
)
.await;
let mut done = false;
for _ in 0..100 {
tokio::time::sleep(Duration::from_millis(200)).await;
let s = json_of(&env.lan, Method::GET, "/api/scan", &c, None).await;
if !s["running"].as_bool().unwrap() {
assert_eq!(s["muxes_found"], 2, "{s}");
assert_eq!(s["services_found"], 4);
assert_eq!(s["channels_created"], 4);
done = true;
break;
}
}
assert!(done, "scan did not finish");
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
let chans = chans.as_array().unwrap();
assert_eq!(chans.len(), 4);
assert_eq!(chans[0]["name"], "TVP1 HD");
assert_eq!(chans[0]["number"], 1);
assert_eq!(chans[1]["name"], "Polsat Śląsk");
assert_eq!(chans[1]["service"]["video"], "HEVC");
let id1 = chans[0]["id"].as_i64().unwrap();
let id2 = chans[1]["id"].as_i64().unwrap();
// reordering
json_of(
&env.lan,
Method::POST,
"/api/channels/order",
&c,
Some(json!({"ids": [id2, id1]})),
)
.await;
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
assert_eq!(chans[0]["id"].as_i64().unwrap(), id2);
// a viewer cannot change the configuration
let vc = login(&env.lan, "widz", "haslo-widza").await;
let (st, _) = call(
&env.lan,
Method::PUT,
&format!("/api/channels/{id1}"),
&vc,
Some(json!({"name": "X"})),
)
.await;
assert_eq!(st, StatusCode::FORBIDDEN);
// M3U: LAN without a token, WAN requires a token
let (st, body) = call(&env.lan, Method::GET, "/playlist.m3u", "", None).await;
assert_eq!(st, StatusCode::OK);
let m3u = String::from_utf8(body).unwrap();
assert!(m3u.starts_with("#EXTM3U"));
assert!(m3u.contains(&format!("/stream/{id1}.ts")));
let (st, _) = call(&env.wan, Method::GET, "/playlist.m3u", "", None).await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
let tok = json_of(
&env.lan,
Method::POST,
"/api/tokens",
&c,
Some(json!({"name": "Sony TV"})),
)
.await;
let token = tok["token"].as_str().unwrap().to_string();
let (st, body) = call(
&env.wan,
Method::GET,
&format!("/playlist.m3u?format=hls&token={token}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK);
let m3u = String::from_utf8(body).unwrap();
assert!(
m3u.contains(&format!("/hls/{id1}/index.m3u8?token={token}")),
"{m3u}"
);
// token restricted to a network
let tok2 = json_of(
&env.lan,
Method::POST,
"/api/tokens",
&c,
Some(json!({"name": "Tylko LAN", "allow_cidrs": "192.168.0.0/16"})),
)
.await;
let (st, _) = call(
&env.wan,
Method::GET,
&format!("/playlist.m3u?token={}", tok2["token"].as_str().unwrap()),
"",
None,
)
.await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
// ---- tvheadend compatibility
let (st, body) = call(
&env.wan,
Method::GET,
&format!("/playlist?auth={token}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK);
let tvh = String::from_utf8(body).unwrap();
assert!(
tvh.contains(&format!(
"/stream/channelid/{id1}?auth={token}&profile=pass"
)),
"{tvh}"
);
assert!(tvh.contains("tvg-id=\"") && tvh.contains("tvg-chno=\"1\""));
for path in [
"/playlist/channels",
"/playlist/channels.m3u",
"/playlist/auth/channels",
] {
let (st, _) = call(
&env.wan,
Method::GET,
&format!("{path}?ticket={token}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK, "{path}");
}
let (st, one) = call(
&env.lan,
Method::GET,
&format!("/playlist/channelid/{id1}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK);
assert_eq!(
String::from_utf8(one).unwrap().matches("#EXTINF").count(),
1
);
// HTTP Basic with a panel login (like tvheadend clients)
let basic = format!("Basic {}", base64_encode("admin:haslo-admina"));
let res = env
.wan
.clone()
.oneshot(
Request::get("/xmltv/channels")
.header(header::AUTHORIZATION, &basic)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(res.status(), StatusCode::OK);
let res = env
.wan
.clone()
.oneshot(
Request::get("/xmltv/channels")
.header(
header::AUTHORIZATION,
format!("Basic {}", base64_encode("admin:zle")),
)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
// stream by channel number
let res = env
.lan
.clone()
.oneshot(
Request::get("/stream/channelnumber/2?profile=webtv-h264-aac-mpegts-unknown")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(res.status(), StatusCode::OK);
let mut b = res.into_body();
let f = tokio::time::timeout(Duration::from_secs(10), b.frame())
.await
.unwrap()
.unwrap()
.unwrap();
assert_eq!(f.into_data().unwrap()[0], 0x47);
drop(b);
let (st, _) = call(&env.lan, Method::GET, "/stream/channelid/99999", "", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
// separate stream port: no panel and no API
let stream_port = web::stream_router(env.state.clone())
.layer(MockConnectInfo(SocketAddr::from(([192, 168, 1, 60], 5000))));
let (st, _) = call(&stream_port, Method::GET, "/playlist", "", None).await;
assert_eq!(st, StatusCode::OK);
let (st, _) = call(&stream_port, Method::GET, "/api/channels", &c, None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
// tvheadend JSON API (PVR Live and other Android TV sources)
let (st, body) = call(&stream_port, Method::GET, "/api/serverinfo", "", None).await;
assert_eq!(st, StatusCode::OK);
let info: serde_json::Value = serde_json::from_slice(&body).unwrap();
assert_eq!(info["name"], "Tvheadend");
let (_, body) = call(
&stream_port,
Method::GET,
"/api/channel/grid?limit=999",
"",
None,
)
.await;
let grid: serde_json::Value = serde_json::from_slice(&body).unwrap();
let first = &grid["entries"][0];
assert_eq!(grid["total"], 4);
assert!(first["name"].is_string());
let uuid = first["uuid"].as_str().unwrap().to_string();
let (_, body) = call(
&stream_port,
Method::GET,
&format!("/api/epg/events/grid?channel={uuid}&limit=5"),
"",
None,
)
.await;
let epg: serde_json::Value = serde_json::from_slice(&body).unwrap();
// EIT has not been collected yet at this point: only the shape is checked
assert!(epg["entries"].is_array(), "{epg}");
assert!(epg["totalCount"].is_number());
let _ = uuid;
// the WAN side needs a token here too
let wan_stream = web::stream_router(env.state.clone())
.layer(MockConnectInfo(SocketAddr::from(([8, 8, 8, 8], 5000))));
let (st, _) = call(&wan_stream, Method::GET, "/api/channel/grid", "", None).await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
let (st, _) = call(
&wan_stream,
Method::GET,
&format!("/api/channel/grid?auth={token}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK);
// HLS
let (st, body) = call(
&env.wan,
Method::GET,
&format!("/hls/{id1}/index.m3u8?token={token}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK, "{}", String::from_utf8_lossy(&body));
let pl = String::from_utf8(body).unwrap();
assert!(pl.contains("#EXT-X-TARGETDURATION"));
let seg_line = pl
.lines()
.find(|l| l.ends_with(&format!("?token={token}")))
.expect("segment in playlist")
.to_string();
let (st, seg) = call(
&env.wan,
Method::GET,
&format!("/hls/{id1}/{seg_line}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK);
assert!(seg.len() > 188 * 10 && seg.len() % 188 == 0);
assert_eq!(seg[0], 0x47);
// second channel from the same mux shares the tuner
let (st, _) = call(
&env.lan,
Method::GET,
&format!("/hls/{id2}/index.m3u8"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK);
let status = json_of(&env.lan, Method::GET, "/api/status", &c, None).await;
assert_eq!(status["tuners"][0]["active"]["state"], "locked");
assert_eq!(status["hls_sessions"].as_array().unwrap().len(), 2);
// raw MPEG-TS
let res = env
.lan
.clone()
.oneshot(
Request::get(format!("/stream/{id1}.ts"))
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(res.headers()[header::CONTENT_TYPE], "video/mp2t");
let mut body = res.into_body();
let frame = tokio::time::timeout(Duration::from_secs(10), body.frame())
.await
.unwrap()
.unwrap()
.unwrap();
let data = frame.into_data().unwrap();
assert_eq!(data[0], 0x47);
drop(body);
// EPG from EIT -> XMLTV
let mut found = false;
for _ in 0..40 {
let (st, body) = call(&env.lan, Method::GET, "/epg.xml", "", None).await;
assert_eq!(st, StatusCode::OK);
let x = String::from_utf8(body).unwrap();
if x.contains("<programme") && x.contains("TVP1 HD - audycja 1") {
assert!(x.contains("<channel id=\""));
found = true;
break;
}
tokio::time::sleep(Duration::from_millis(250)).await;
}
assert!(found, "no EPG in XMLTV");
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
assert!(
chans
.as_array()
.unwrap()
.iter()
.any(|ch| !ch["now"].is_null()),
"no current programme"
);
// public sharing
let sh = json_of(
&env.lan,
Method::POST,
&format!("/api/channels/{id1}/share"),
&c,
Some(json!({"enabled": true})),
)
.await;
let share = sh["token"].as_str().unwrap().to_string();
let (st, page) = call(&env.wan, Method::GET, &format!("/watch/{share}"), "", None).await;
assert_eq!(st, StatusCode::OK);
assert!(String::from_utf8_lossy(&page).contains("TVP1 HD"));
let (st, _) = call(
&env.wan,
Method::GET,
&format!("/hls/{id1}/index.m3u8?share={share}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::OK);
let (st, _) = call(
&env.wan,
Method::GET,
&format!("/hls/{id2}/index.m3u8?share={share}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
let (st, _) = call(
&env.wan,
Method::GET,
&format!("/playlist.m3u?share={share}"),
"",
None,
)
.await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
json_of(
&env.lan,
Method::POST,
&format!("/api/channels/{id1}/share"),
&c,
Some(json!({"enabled": false})),
)
.await;
let (st, _) = call(&env.wan, Method::GET, &format!("/watch/{share}"), "", None).await;
assert_eq!(st, StatusCode::NOT_FOUND);
// manual recording (about 8 s of stream at 4x speed)
let now = chrono::Utc::now().timestamp();
let rec = json_of(
&env.lan,
Method::POST,
"/api/recordings",
&c,
Some(json!({"channel_id": id1, "title": "Test recording", "start": now, "stop": now + 8})),
)
.await;
let rid = rec["id"].as_i64().unwrap();
let mut status = String::new();
for _ in 0..120 {
tokio::time::sleep(Duration::from_millis(250)).await;
let r = json_of(&env.lan, Method::GET, "/api/recordings", &c, None).await;
status = r[0]["status"].as_str().unwrap().to_string();
if status == "completed" || status == "failed" {
break;
}
}
assert_eq!(status, "completed");
let (st, pl) = call(
&env.lan,
Method::GET,
&format!("/recordings/{rid}/index.m3u8"),
&c,
None,
)
.await;
assert_eq!(st, StatusCode::OK);
let pl = String::from_utf8(pl).unwrap();
assert!(
pl.contains("#EXT-X-BYTERANGE:") && pl.contains("#EXT-X-ENDLIST"),
"{pl}"
);
let res = env
.lan
.clone()
.oneshot(
Request::get(format!("/recordings/{rid}/file"))
.header(header::COOKIE, &c)
.header(header::RANGE, "bytes=0-187")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(res.status(), StatusCode::PARTIAL_CONTENT);
let b = res.into_body().collect().await.unwrap().to_bytes();
assert_eq!(b.len(), 188);
assert_eq!(b[0], 0x47);
// settings: validation
let mut s = json_of(&env.lan, Method::GET, "/api/settings", &c, None).await;
s["hls_window"] = json!(1);
let (st, _) = call(&env.lan, Method::PUT, "/api/settings", &c, Some(s.clone())).await;
assert_eq!(st, StatusCode::BAD_REQUEST);
s["hls_window"] = json!(10);
s["stream_open_cidrs"] = json!([]);
json_of(&env.lan, Method::PUT, "/api/settings", &c, Some(s)).await;
// LAN without a token is no longer open, but a panel session is enough
let (st, _) = call(&env.lan, Method::GET, "/playlist.m3u", "", None).await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
let (st, _) = call(&env.lan, Method::GET, "/playlist.m3u", &c, None).await;
assert_eq!(st, StatusCode::OK);
// series recording rule: matches upcoming “TVN - audycja N” programmes from EIT
let rule = json_of(
&env.lan,
Method::POST,
"/api/autorec",
&c,
Some(json!({"name": "TVN", "pattern": "^TVN - audycja [2-4]$"})),
)
.await;
assert!(rule["scheduled"].as_u64().unwrap() >= 1, "{rule}");
let recs = json_of(&env.lan, Method::GET, "/api/recordings", &c, None).await;
assert!(recs
.as_array()
.unwrap()
.iter()
.any(|r| r["autorec_id"] == rule["id"] && r["status"] == "scheduled"));
// running it again does not create duplicates
let again = simply_dvb::recorder::run_autorec(&env.state).await.unwrap();
assert_eq!(again.0, 0);
json_of(
&env.lan,
Method::DELETE,
&format!("/api/autorec/{}", rule["id"]),
&c,
None,
)
.await;
// Prometheus metrics
let (st, body) = call(&env.lan, Method::GET, "/metrics", &c, None).await;
assert_eq!(st, StatusCode::OK);
let m = String::from_utf8(body).unwrap();
assert!(
m.contains("simply_dvb_tuner_locked{adapter=\"virtual0\""),
"{m}"
);
assert!(m.contains("simply_dvb_channels{enabled=\"true\"}"));
let (st, _) = call(&env.wan, Method::GET, "/metrics", "", None).await;
assert_eq!(st, StatusCode::UNAUTHORIZED);
// backup and restore
let (st, backup) = call(&env.lan, Method::GET, "/api/backup", &c, None).await;
assert_eq!(st, StatusCode::OK);
let backup: Value = serde_json::from_slice(&backup).unwrap();
assert_eq!(backup["channels"].as_array().unwrap().len(), 4);
json_of(
&env.lan,
Method::DELETE,
&format!("/api/channels/{id1}"),
&c,
None,
)
.await;
let r = json_of(&env.lan, Method::POST, "/api/restore", &c, Some(backup)).await;
assert_eq!(r["channels"], 4);
let chans = json_of(&env.lan, Method::GET, "/api/channels", &c, None).await;
assert_eq!(chans.as_array().unwrap().len(), 4);
env.state.tuners.shutdown();
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn xmltv_import_maps_channels() {
let env = setup().await;
let c = env.cookie.clone();
let db = &env.state.db;
let ch = db.create_channel(1, "TVP 1", None, "TV").await.unwrap();
db.create_channel(2, "Other channel", None, "TV")
.await
.unwrap();
let xml = r#"<tv><channel id="TVP1.pl"><display-name>TVP1</display-name></channel>
<programme start="20990101060000 +0100" stop="20990101070000 +0100" channel="TVP1.pl"><title>Teleexpress</title><desc>Wiadomości</desc></programme>
<programme start="20990101070000 +0100" stop="20990101080000 +0100" channel="Nieznany"><title>X</title></programme></tv>"#;
let (matched, n) = epg::import_xml(&env.state, xml).await.unwrap();
assert_eq!((matched, n), (1, 1));
let ev = json_of(
&env.lan,
Method::GET,
&format!("/api/epg?channel={ch}&from=4070900000&to=4071000000"),
&c,
None,
)
.await;
assert_eq!(ev[0]["title"], "Teleexpress");
assert_eq!(ev[0]["source"], "xmltv");
}
fn base64_encode(s: &str) -> String {
use base64::Engine;
base64::engine::general_purpose::STANDARD.encode(s)
}
/// HTSP client side of the wire format (enough for the test).
mod htsp_client {
pub use simply_dvb::htsp::msg::{Msg, Val};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
pub async fn send(s: &mut TcpStream, m: Msg) {
s.write_all(&m.encode()).await.unwrap();
}
pub async fn recv(s: &mut TcpStream) -> Msg {
let mut l = [0u8; 4];
s.read_exact(&mut l).await.unwrap();
let mut b = vec![0u8; u32::from_be_bytes(l) as usize];
s.read_exact(&mut b).await.unwrap();
Msg::decode(&b).unwrap()
}
/// Sends a request and returns its reply (async messages are collected into `seen`).
pub async fn call(s: &mut TcpStream, seq: i64, m: Msg, seen: &mut Vec<Msg>) -> Msg {
send(s, m.int("seq", seq)).await;
loop {
let r = recv(s).await;
if r.get_i64("seq") == Some(seq) {
return r;
}
seen.push(r);
}
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn htsp_protocol() {
use htsp_client::*;
let env = setup().await;
let c = env.cookie.clone();
json_of(
&env.lan,
Method::POST,
"/api/scan",
&c,
Some(json!({"preset": "custom", "frequencies_mhz": [538], "follow_nit": false})),
)
.await;
for _ in 0..100 {
tokio::time::sleep(Duration::from_millis(200)).await;
let s = json_of(&env.lan, Method::GET, "/api/scan", &c, None).await;
if !s["running"].as_bool().unwrap() {
break;
}
}
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let (_stop_tx, stop_rx) = tokio::sync::watch::channel(false);
tokio::spawn(simply_dvb::htsp::serve(
env.state.clone(),
listener,
stop_rx,
));
let mut s = tokio::net::TcpStream::connect(addr).await.unwrap();
let mut seen = Vec::new();
let hello = call(
&mut s,
1,
Msg::method("hello")
.int("htspversion", 34)
.str("clientname", "Kodi")
.str("clientversion", "21"),
&mut seen,
)
.await;
assert_eq!(hello.get_i64("htspversion"), Some(34));
assert_eq!(hello.get_bin("challenge").unwrap().len(), 32);
// 127.0.0.1 is in the default open networks: no credentials needed
let auth = call(&mut s, 2, Msg::method("authenticate"), &mut seen).await;
assert!(auth.get("noaccess").is_none(), "{auth:?}");
call(
&mut s,
3,
Msg::method("enableAsyncMetadata").int("epg", 1),
&mut seen,
)
.await;
loop {
let m = recv(&mut s).await;
let done = m.get_str("method") == Some("initialSyncCompleted");
seen.push(m);
if done {
break;
}
}
let channels: Vec<&Msg> = seen
.iter()
.filter(|m| m.get_str("method") == Some("channelAdd"))
.collect();
assert_eq!(channels.len(), 3, "{seen:?}");
assert_eq!(channels[0].get_str("channelName"), Some("TVP1 HD"));
assert!(seen.iter().any(|m| m.get_str("method") == Some("tagAdd")));
let ch = channels[0].get_i64("channelId").unwrap();
call(
&mut s,
4,
Msg::method("subscribe")
.int("subscriptionId", 9)
.int("channelId", ch),
&mut seen,
)
.await;
let mut started = false;
let mut video = 0;
let mut audio = 0;
let mut first_key = None;
let deadline = tokio::time::Instant::now() + Duration::from_secs(15);
while tokio::time::Instant::now() < deadline && (video < 20 || audio < 20) {
let m = tokio::time::timeout(Duration::from_secs(5), recv(&mut s))
.await
.expect("no HTSP data");
match m.get_str("method") {
Some("subscriptionStart") => {
let Some(Val::List(streams)) = m.get("streams") else {
panic!("no streams")
};
assert!(streams.len() >= 2);
started = true;
}
Some("muxpkt") => {
assert!(started, "muxpkt before subscriptionStart");
assert!(!m.get_bin("payload").unwrap().is_empty());
if m.get_i64("stream") == Some(1) {
first_key.get_or_insert(m.get_i64("frametype").unwrap());
video += 1;
} else {
audio += 1;
}
}
Some("subscriptionStop") => panic!("stopped: {m:?}"),
_ => {}
}
}
assert!(video >= 20 && audio >= 20, "video {video} audio {audio}");
// the stream starts with a keyframe
assert_eq!(first_key, Some('I' as i64));
let r = call(
&mut s,
5,
Msg::method("unsubscribe").int("subscriptionId", 9),
&mut seen,
)
.await;
assert!(r.get("error").is_none());
}