first commit
build / test (push) Canceled after 0s
build / deb (amd64) (push) Canceled after 0s
build / deb (arm64) (push) Canceled after 0s
build / deb (armhf) (push) Canceled after 0s

This commit is contained in:
Mateusz Gruszczyński committed 2026-11-16 16:19:21 +01:00
commit c30064b531
93 files changed
+26367

No files matched your search

+891
View File
@@ -0,0 +1,891 @@
//! 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,
};
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);
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);
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());
}