//! 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, ) -> (StatusCode, Vec) { 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 { 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("= 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#"TVP1 TeleexpressWiadomości X"#; 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 { 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()); }