Skip to main content

radio_cli/podcast/
feed.rs

1use super::*;
2use crate::config::Config;
3use anyhow::Result;
4use quick_xml::{Reader, events::Event};
5use reqwest::{
6    Url,
7    blocking::{Client, Response},
8};
9use scraper::{Html, Selector};
10use std::{
11    io::Read,
12    sync::{
13        Arc,
14        atomic::{AtomicBool, Ordering},
15    },
16    time::Duration,
17};
18const LIMIT: u64 = 10 * 1024 * 1024;
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub struct Preview {
21    pub feed: Feed,
22    pub episodes: Vec<Episode>,
23}
24pub(crate) fn url(value: &str, base: Option<&Url>) -> Result<Url> {
25    let mut u = match base {
26        Some(b) => b.join(value),
27        None => Url::parse(value),
28    }
29    .map_err(|_| error(crate::t!("podcast_invalid_url")))?;
30    if !matches!(u.scheme(), "http" | "https")
31        || u.host_str().is_none()
32        || !u.username().is_empty()
33        || u.password().is_some()
34    {
35        return Err(error(crate::t!("podcast_invalid_url")));
36    }
37    u.set_fragment(None);
38    Ok(u)
39}
40pub(crate) fn client(config: &Config) -> Result<Client> {
41    Client::builder()
42        .user_agent(crate::USER_AGENT)
43        .connect_timeout(Duration::from_secs(config.settings.connect_timeout_secs))
44        .timeout(Duration::from_secs(config.settings.request_timeout_secs))
45        .redirect(reqwest::redirect::Policy::custom(|a| {
46            if a.previous().len() >= 5
47                || !matches!(a.url().scheme(), "http" | "https")
48                || !a.url().username().is_empty()
49                || a.url().password().is_some()
50            {
51                a.stop()
52            } else {
53                a.follow()
54            }
55        }))
56        .build()
57        .map_err(|_| error(crate::t!("podcast_network")))
58}
59pub(crate) fn body(mut r: Response, stop: &AtomicBool) -> Result<(Url, Vec<u8>)> {
60    if !r.status().is_success() {
61        return Err(error(&format!(
62            "{} {}",
63            crate::t!("podcast_http"),
64            r.status().as_u16()
65        )));
66    }
67    let base = r.url().clone();
68    let mut data = Vec::new();
69    let mut buf = [0; 16384];
70    loop {
71        if stop.load(Ordering::Relaxed) {
72            return Err(DomainError::new(ErrorCode::Cancelled).into());
73        }
74        let n = r
75            .read(&mut buf)
76            .map_err(|_| error(crate::t!("podcast_network")))?;
77        if n == 0 {
78            break;
79        }
80        if data.len() as u64 + n as u64 > LIMIT {
81            return Err(error(crate::t!("podcast_limit")));
82        }
83        data.extend_from_slice(&buf[..n]);
84    }
85    Ok((base, data))
86}
87pub fn fetch(
88    config: &Config,
89    value: &str,
90    old: Option<&Feed>,
91    stop: &Arc<AtomicBool>,
92) -> Result<Option<Preview>> {
93    let u = url(value, None)?;
94    let mut req = client(config)?.get(u);
95    if let Some(f) = old {
96        if let Some(v) = &f.etag {
97            req = req.header("If-None-Match", v);
98        }
99        if let Some(v) = &f.modified {
100            req = req.header("If-Modified-Since", v);
101        }
102    }
103    let r = req
104        .send()
105        .map_err(|_| error(crate::t!("podcast_network")))?;
106    if r.status() == 304 && old.is_some() {
107        return Ok(None);
108    }
109    let etag = r
110        .headers()
111        .get("etag")
112        .and_then(|h| h.to_str().ok())
113        .map(str::to_owned);
114    let modified = r
115        .headers()
116        .get("last-modified")
117        .and_then(|h| h.to_str().ok())
118        .map(str::to_owned);
119    let (base, data) = body(r, stop)?;
120    let mut p = parse(&data, &base)?;
121    p.feed.etag = etag;
122    p.feed.modified = modified;
123    p.feed.refreshed_at = Some(chrono::Utc::now().to_rfc3339());
124    Ok(Some(p))
125}
126fn plain(value: &str) -> String {
127    Html::parse_fragment(value)
128        .root_element()
129        .text()
130        .collect::<Vec<_>>()
131        .join(" ")
132        .split_whitespace()
133        .collect::<Vec<_>>()
134        .join(" ")
135}
136fn duration(value: &str) -> Option<u64> {
137    let mut n = 0u64;
138    for part in value.trim().split(':') {
139        n = n.checked_mul(60)?.checked_add(part.parse::<u64>().ok()?)?;
140    }
141    n.checked_mul(1000)
142}
143struct Node {
144    name: String,
145    text: String,
146    base: Url,
147    html: bool,
148    updated: Option<String>,
149}
150#[derive(Clone, Copy, PartialEq, Eq)]
151enum Scope {
152    Feed,
153    Episode,
154    Other,
155}
156fn scope(stack: &[Node]) -> Scope {
157    match stack {
158        [feed] if feed.name == "feed" => Scope::Feed,
159        [rss, channel] if rss.name == "rss" && channel.name == "channel" => Scope::Feed,
160        [feed, entry] if feed.name == "feed" && entry.name == "entry" => Scope::Episode,
161        [rss, channel, item]
162            if rss.name == "rss" && channel.name == "channel" && item.name == "item" =>
163        {
164            Scope::Episode
165        }
166        _ => Scope::Other,
167    }
168}
169pub(crate) fn parse(data: &[u8], base: &Url) -> Result<Preview> {
170    if data.len() as u64 > LIMIT {
171        return Err(error(crate::t!("podcast_limit")));
172    }
173    if data.starts_with(&[0xff, 0xfe]) || data.starts_with(&[0xfe, 0xff]) {
174        return Err(error(crate::t!("podcast_invalid_feed")));
175    }
176    let invalid = || error(crate::t!("podcast_invalid_feed"));
177    let mut reader = Reader::from_reader(data);
178    reader.config_mut().check_end_names = true;
179    let mut stack: Vec<Node> = vec![];
180    let mut f = Feed {
181        url: base.to_string(),
182        ..Default::default()
183    };
184    let mut episodes = vec![];
185    let mut current: Option<Episode> = None;
186    let mut count = 0;
187    let mut root = String::new();
188    loop {
189        match reader.read_event().map_err(|_| invalid())? {
190            Event::Start(e) | Event::Empty(e) => {
191                let empty =
192                    data.get(reader.buffer_position().saturating_sub(2) as usize) == Some(&b'/');
193                let name = e.local_name().as_ref().to_owned();
194                if stack.is_empty() {
195                    if !root.is_empty() || !matches!(name.as_str(), "rss" | "feed") {
196                        return Err(invalid());
197                    }
198                    root = name.clone();
199                }
200                if stack.len() >= 64 {
201                    return Err(error(crate::t!("podcast_limit")));
202                }
203                let parent_base = stack.last().map(|n| &n.base).unwrap_or(base);
204                let mut attrs = std::collections::HashMap::new();
205                for a in e.attributes() {
206                    let a = a.map_err(|_| invalid())?;
207                    attrs.insert(
208                        a.key.as_ref().to_owned(),
209                        a.normalized_value(quick_xml::XmlVersion::Implicit1_0)
210                            .map_err(|_| invalid())?
211                            .into_owned(),
212                    );
213                }
214                let node_base = if let Some(b) = attrs.get("xml:base") {
215                    url(b, Some(parent_base))?
216                } else {
217                    parent_base.clone()
218                };
219                let attr_url = |key: &str| {
220                    attrs
221                        .get(key)
222                        .and_then(|v| url(v, Some(&node_base)).ok())
223                        .map(|u| u.to_string())
224                };
225                let parent_scope = scope(&stack);
226                if parent_scope == Scope::Feed
227                    && ((root == "feed" && name == "entry") || (root == "rss" && name == "item"))
228                {
229                    count += 1;
230                    if count > 10000 || current.is_some() {
231                        return Err(error(crate::t!("podcast_limit")));
232                    }
233                    current = Some(Episode::default());
234                }
235                if parent_scope == Scope::Episode
236                    && (name == "enclosure"
237                        || (name == "link" && attrs.get("rel").is_some_and(|r| r == "enclosure")))
238                {
239                    if let Some(ep) = current.as_mut() {
240                        let mime = attrs.get("type").cloned().unwrap_or_default();
241                        if ep.url.is_empty()
242                            && (mime.is_empty()
243                                || mime.starts_with("audio/")
244                                || mime == "application/octet-stream")
245                            && let Some(u) = attr_url(if name == "link" { "href" } else { "url" })
246                        {
247                            ep.url = u;
248                            ep.mime = mime;
249                            ep.bytes = attrs.get("length").and_then(|v| v.parse().ok());
250                        }
251                    }
252                } else if parent_scope == Scope::Feed
253                    && name == "image"
254                    && let Some(u) = attr_url("href")
255                {
256                    f.image = u;
257                } else if matches!(parent_scope, Scope::Feed | Scope::Episode)
258                    && name == "link"
259                    && attrs.get("rel").is_none_or(|v| v == "alternate")
260                    && let Some(u) = attr_url("href")
261                {
262                    if let Some(e) = current.as_mut() {
263                        e.website = u;
264                    } else {
265                        f.website = u;
266                    }
267                }
268                stack.push(Node {
269                    name,
270                    text: String::new(),
271                    base: node_base,
272                    // XHTML tags are consumed by the XML reader. Only HTML
273                    // needs another parsing pass after XML entity decoding.
274                    html: root != "feed"
275                        || attrs
276                            .get("type")
277                            .is_some_and(|t| matches!(t.as_str(), "html" | "text/html")),
278                    updated: None,
279                });
280                if !empty {
281                    continue;
282                }
283                finish(&mut stack, &mut f, &mut current, &mut episodes);
284            }
285            Event::End(_) => finish(&mut stack, &mut f, &mut current, &mut episodes),
286            Event::Text(t) => {
287                if let Some(n) = stack.last_mut() {
288                    n.text.push_str(t.as_ref());
289                }
290            }
291            Event::CData(t) => {
292                if let Some(n) = stack.last_mut() {
293                    n.text.push_str(t.as_ref());
294                }
295            }
296            Event::GeneralRef(t) => {
297                if let Some(n) = stack.last_mut() {
298                    let t = t.as_ref();
299                    let v = quick_xml::escape::unescape(&format!("&{t};"))
300                        .map_err(|_| invalid())?
301                        .into_owned();
302                    n.text.push_str(&v);
303                }
304            }
305            Event::DocType(_) => return Err(invalid()),
306            Event::Eof => break,
307            _ => {}
308        }
309    }
310    if !stack.is_empty() || root.is_empty() || f.title.is_empty() || episodes.is_empty() {
311        return Err(invalid());
312    }
313    Ok(Preview { feed: f, episodes })
314}
315fn finish(
316    stack: &mut Vec<Node>,
317    f: &mut Feed,
318    current: &mut Option<Episode>,
319    episodes: &mut Vec<Episode>,
320) {
321    let Some(n) = stack.pop() else { return };
322    let text = n.text.trim();
323    let display_text = || {
324        if n.html {
325            plain(text)
326        } else {
327            text.split_whitespace().collect::<Vec<_>>().join(" ")
328        }
329    };
330    let parent = stack.last().map(|n| n.name.as_str()).unwrap_or("");
331    let parent_scope = scope(stack);
332    let resolved = || {
333        url(text, Some(&n.base))
334            .map(|u| u.to_string())
335            .unwrap_or_default()
336    };
337    if let Some(e) = current.as_mut() {
338        if parent_scope == Scope::Episode {
339            match n.name.as_str() {
340                "title" => e.title = display_text(),
341                "guid" | "id" if !text.is_empty() => e.guid = Some(text.into()),
342                "description" | "summary" | "content" => e.description = display_text(),
343                "pubDate" | "published" => {
344                    e.published = chrono::DateTime::parse_from_rfc2822(text)
345                        .or_else(|_| chrono::DateTime::parse_from_rfc3339(text))
346                        .ok()
347                        .map(|d| d.to_utc().to_rfc3339())
348                }
349                "updated" => {
350                    stack.last_mut().unwrap().updated = chrono::DateTime::parse_from_rfc3339(text)
351                        .ok()
352                        .map(|d| d.to_utc().to_rfc3339());
353                }
354                "link" if !text.is_empty() => e.website = resolved(),
355                "duration" => e.duration_ms = duration(text),
356                _ => {}
357            }
358        }
359        if parent_scope == Scope::Feed && matches!(n.name.as_str(), "item" | "entry") {
360            let mut e = current.take().unwrap();
361            e.published = e.published.or(n.updated);
362            if !e.url.is_empty() {
363                episodes.push(e);
364            }
365        }
366    } else {
367        let nested_feed_field = stack
368            .split_last()
369            .is_some_and(|(_, ancestors)| scope(ancestors) == Scope::Feed);
370        match n.name.as_str() {
371            "title" if parent_scope == Scope::Feed => f.title = display_text(),
372            "author" | "managingEditor" if parent_scope == Scope::Feed => f.author = display_text(),
373            "name" if parent == "author" && nested_feed_field => f.author = display_text(),
374            "description" | "subtitle" if parent_scope == Scope::Feed => {
375                f.description = display_text()
376            }
377            "link" if parent_scope == Scope::Feed && !text.is_empty() => f.website = resolved(),
378            "url" if parent == "image" && nested_feed_field && f.image.is_empty() => {
379                f.image = resolved()
380            }
381            "logo" | "icon" if parent_scope == Scope::Feed => f.image = resolved(),
382            _ => {}
383        }
384    }
385    if let Some(parent) = stack.last_mut().filter(|p| {
386        !matches!(
387            p.name.as_str(),
388            "rss" | "channel" | "feed" | "item" | "entry"
389        )
390    }) && parent.text.len().saturating_add(n.text.len()) <= 1024 * 1024
391    {
392        parent.text.push_str(&n.text);
393    }
394}
395pub fn discover(config: &Config, value: &str, stop: &Arc<AtomicBool>) -> Result<Vec<String>> {
396    let u = url(value, None)?;
397    if matches!(
398        u.host_str(),
399        Some("podcasts.apple.com" | "itunes.apple.com")
400    ) && let Some(id) = u
401        .path_segments()
402        .and_then(|s| {
403            s.filter_map(|p| p.strip_prefix("id").map(str::to_owned))
404                .next_back()
405        })
406        .or_else(|| {
407            u.query_pairs()
408                .find(|(k, _)| k == "id")
409                .map(|(_, v)| v.into_owned())
410        })
411    {
412        return apple(config, "lookup", &[("id", &id)], stop).map(|v| {
413            v.into_iter()
414                .filter_map(|v| {
415                    v["feedUrl"]
416                        .as_str()
417                        .and_then(|s| url(s, None).ok())
418                        .map(|u| u.to_string())
419                })
420                .collect()
421        });
422    }
423    let (base, data) = body(
424        client(config)?
425            .get(u)
426            .send()
427            .map_err(|_| error(crate::t!("podcast_network")))?,
428        stop,
429    )?;
430    if parse(&data, &base).is_ok() {
431        return Ok(vec![base.to_string()]);
432    }
433    let html = Html::parse_document(&String::from_utf8_lossy(&data));
434    let mut found = vec![];
435    let base = html
436        .select(&Selector::parse("head base[href]").unwrap())
437        .next()
438        .and_then(|e| url(e.value().attr("href")?, Some(&base)).ok())
439        .unwrap_or(base);
440    for e in html.select(&Selector::parse("head link[href]").unwrap()) {
441        let rel = e.value().attr("rel").unwrap_or("");
442        let mime = e.value().attr("type").unwrap_or("").to_ascii_lowercase();
443        if rel
444            .split_whitespace()
445            .any(|r| r.eq_ignore_ascii_case("alternate") || r.eq_ignore_ascii_case("feed"))
446            && matches!(
447                mime.as_str(),
448                "application/rss+xml" | "application/atom+xml"
449            )
450            && let Some(u) = e
451                .value()
452                .attr("href")
453                .and_then(|s| url(s, Some(&base)).ok())
454            && !found.contains(&u.to_string())
455        {
456            found.push(u.to_string());
457        }
458    }
459    Ok(found)
460}
461fn apple(
462    config: &Config,
463    endpoint: &str,
464    args: &[(&str, &str)],
465    stop: &Arc<AtomicBool>,
466) -> Result<Vec<serde_json::Value>> {
467    use std::sync::{Mutex, OnceLock};
468    use std::time::Instant;
469    type Cache = std::collections::HashMap<String, (Instant, Vec<serde_json::Value>)>;
470    static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
471    static LAST: Mutex<Option<Instant>> = Mutex::new(None);
472    let key = format!("{endpoint}{args:?}");
473    let cache = CACHE.get_or_init(Mutex::default);
474    if let Some((at, v)) = cache.lock().unwrap().get(&key)
475        && at.elapsed() < Duration::from_secs(600)
476    {
477        return Ok(v.clone());
478    }
479    {
480        let mut last = LAST.lock().unwrap();
481        while last.is_some_and(|at| at.elapsed() < Duration::from_secs(3)) {
482            if stop.load(Ordering::Relaxed) {
483                return Err(DomainError::new(ErrorCode::Cancelled).into());
484            }
485            std::thread::sleep(Duration::from_millis(50));
486        }
487        *last = Some(Instant::now());
488    }
489    let r = client(config)?
490        .get(format!("https://itunes.apple.com/{endpoint}"))
491        .query(args)
492        .send()
493        .map_err(|_| error(crate::t!("podcast_network")))?;
494    if r.status() == 429 {
495        let seconds = r
496            .headers()
497            .get("retry-after")
498            .and_then(|v| v.to_str().ok())
499            .and_then(|v| v.parse::<u64>().ok())
500            .unwrap_or(60)
501            .min(3600);
502        *LAST.lock().unwrap() = Some(Instant::now() + Duration::from_secs(seconds));
503        return Err(error(crate::t!("podcast_rate_limited")));
504    }
505    let (_, data) = body(r, stop)?;
506    let value: serde_json::Value =
507        serde_json::from_slice(&data).map_err(|_| error(crate::t!("podcast_invalid_feed")))?;
508    let rows = value["results"].as_array().cloned().unwrap_or_default();
509    let mut c = cache.lock().unwrap();
510    if c.len() > 100 {
511        c.clear();
512    }
513    c.insert(key, (Instant::now(), rows.clone()));
514    Ok(rows)
515}
516pub fn search(
517    config: &Config,
518    query: &str,
519    country: &str,
520    limit: usize,
521    stop: &Arc<AtomicBool>,
522) -> Result<Vec<serde_json::Value>> {
523    apple(
524        config,
525        "search",
526        &[
527            ("term", query),
528            ("media", "podcast"),
529            ("entity", "podcast"),
530            ("country", country),
531            ("limit", &limit.to_string()),
532        ],
533        stop,
534    )
535}
536
537#[cfg(test)]
538mod tests {
539    use super::*;
540    fn parse_xml(xml: &str) -> Result<Preview> {
541        parse(
542            xml.as_bytes(),
543            &Url::parse("https://example.test/a/feed").unwrap(),
544        )
545    }
546    #[test]
547    fn atom_source_metadata_stays_separate_from_entry_identity_and_content() {
548        for source_first in [false, true] {
549            let source = r#"<source xml:base="https://source.test/">
550                <id>shared-source</id><title>Source title</title>
551                <updated>2026-02-01T00:00:00Z</updated>
552                <link rel="alternate" href="source"/>
553                <link rel="enclosure" href="source.mp3" type="audio/mpeg"/>
554                <logo>source.jpg</logo><author><name>Source author</name></author>
555                </source>"#;
556            let entries = ["one", "two"].map(|id| {
557                let fields = format!(
558                    r#"<id>{id}</id><title>Episode {id}</title>
559                    <published>2026-01-01T00:00:00Z</published>
560                    <summary>Episode description</summary>
561                    <link rel="alternate" href="{id}"/>
562                    <link rel="enclosure" href="{id}.mp3" type="audio/mpeg"/>"#
563                );
564                if source_first {
565                    format!("<entry>{source}{fields}</entry>")
566                } else {
567                    format!("<entry>{fields}{source}</entry>")
568                }
569            });
570            let p = parse_xml(&format!(
571                r#"<feed xmlns="http://www.w3.org/2005/Atom">
572                <title>Show</title><author><name>Show author</name></author>
573                <logo>show.jpg</logo>{}</feed>"#,
574                entries.join("")
575            ))
576            .unwrap();
577            assert_eq!(p.feed.author, "Show author");
578            assert_eq!(p.feed.image, "https://example.test/a/show.jpg");
579            for (episode, id) in p.episodes.iter().zip(["one", "two"]) {
580                assert_eq!(episode.guid.as_deref(), Some(id));
581                assert_eq!(episode.title, format!("Episode {id}"));
582                assert_eq!(episode.description, "Episode description");
583                assert_eq!(
584                    episode.published.as_deref(),
585                    Some("2026-01-01T00:00:00+00:00")
586                );
587                assert_eq!(episode.website, format!("https://example.test/a/{id}"));
588                assert_eq!(episode.url, format!("https://example.test/a/{id}.mp3"));
589            }
590            let dir = tempfile::tempdir().unwrap();
591            let store = crate::store::Store::open(&dir.path().join("radio.db")).unwrap();
592            let feed = store.podcast_subscribe(&p, &p.feed.url).unwrap();
593            assert_eq!(store.podcast_episodes(&feed.id).unwrap().len(), 2);
594        }
595    }
596    #[test]
597    fn rss_episode_images_never_replace_or_supply_show_artwork() {
598        for show_image in ["", r#"<itunes:image href="show.jpg"/>"#] {
599            for show_first in [false, true] {
600                let episodes = r#"<item><title>One</title><enclosure url="one.mp3"/>
601                    <itunes:image href="one.jpg"/></item>
602                    <item><title>Two</title><enclosure url="two.mp3"/>
603                    <itunes:image href="two.jpg"/></item>"#;
604                let content = if show_first {
605                    format!("{show_image}{episodes}")
606                } else {
607                    format!("{episodes}{show_image}")
608                };
609                let p = parse_xml(&format!(
610                    r#"<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd">
611                    <channel><title>Show</title>{content}</channel></rss>"#
612                ))
613                .unwrap();
614                assert_eq!(p.episodes.len(), 2);
615                assert_eq!(
616                    p.feed.image,
617                    if show_image.is_empty() {
618                        ""
619                    } else {
620                        "https://example.test/a/show.jpg"
621                    }
622                );
623            }
624        }
625        let p = parse_xml(
626            r#"<rss><channel><title>Show</title><image>
627            <title>Image title</title><url>rss.jpg</url><link>https://image.test/</link>
628            </image><link>https://show.test/</link>
629            <item><title>Episode</title><enclosure url="one.mp3"/></item>
630            </channel></rss>"#,
631        )
632        .unwrap();
633        assert_eq!(p.feed.title, "Show");
634        assert_eq!(p.feed.website, "https://show.test/");
635        assert_eq!(p.feed.image, "https://example.test/a/rss.jpg");
636    }
637    #[test]
638    fn rss_metadata_entities_cdata_and_relative_enclosures() {
639        let p=parse_xml(r#"<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"><channel><title>节目 &amp; 测试</title><itunes:author>作者</itunes:author><item><title><![CDATA[第 <b>一</b> 集]]></title><guid>opaque</guid><itunes:duration>1:02:03</itunes:duration><enclosure url="../audio.m4a?a=1&amp;b=2" type="audio/mp4" length="123"/></item></channel></rss>"#).unwrap();
640        assert_eq!(p.feed.title, "节目 & 测试");
641        assert_eq!(p.feed.author, "作者");
642        assert_eq!(p.episodes[0].title, "第 一 集");
643        assert_eq!(p.episodes[0].duration_ms, Some(3723000));
644        assert_eq!(p.episodes[0].bytes, Some(123));
645        assert_eq!(p.episodes[0].url, "https://example.test/audio.m4a?a=1&b=2");
646    }
647    #[test]
648    fn atom_enclosures_respect_xml_base_and_unknown_duration() {
649        let p=parse_xml(r#"<feed xmlns="http://www.w3.org/2005/Atom" xml:base="https://media.test/"><title>Atom</title><entry><id>x</id><title>one</title><link rel="enclosure" href="one.mp3" type="audio/mpeg"/></entry></feed>"#).unwrap();
650        assert_eq!(p.episodes[0].url, "https://media.test/one.mp3");
651        assert_eq!(p.episodes[0].duration_ms, None);
652    }
653    #[test]
654    fn atom_publication_dates_prefer_published_independently_of_tag_order() {
655        let published = "<published>2026-01-01T00:00:00Z</published>";
656        let updated = "<updated>2026-03-01T00:00:00Z</updated>";
657        for (dates, expected) in [
658            (format!("{published}{updated}"), "2026-01-01T00:00:00+00:00"),
659            (format!("{updated}{published}"), "2026-01-01T00:00:00+00:00"),
660            (published.into(), "2026-01-01T00:00:00+00:00"),
661            (updated.into(), "2026-03-01T00:00:00+00:00"),
662            (
663                format!("{updated}<published>invalid</published>"),
664                "2026-03-01T00:00:00+00:00",
665            ),
666            (
667                format!("<published>invalid</published>{updated}"),
668                "2026-03-01T00:00:00+00:00",
669            ),
670            (
671                format!("{published}<updated>invalid</updated>"),
672                "2026-01-01T00:00:00+00:00",
673            ),
674        ] {
675            let p = parse_xml(&format!(
676                r#"<feed xmlns="http://www.w3.org/2005/Atom"><title>Show</title>
677                <entry><id>one</id><title>One</title>{dates}<link rel="enclosure" href="one.mp3"/></entry>
678                <entry><id>two</id><title>Two</title><published>2026-02-01T00:00:00Z</published>
679                <link rel="enclosure" href="two.mp3"/></entry></feed>"#
680            )).unwrap();
681            assert_eq!(
682                p.episodes[0].published.as_deref(),
683                Some(expected),
684                "{dates}"
685            );
686            let dir = tempfile::tempdir().unwrap();
687            let store = crate::store::Store::open(&dir.path().join("radio.db")).unwrap();
688            let feed = store.podcast_subscribe(&p, &p.feed.url).unwrap();
689            let (page, total) = store
690                .podcast_episodes_page(
691                    &feed.id,
692                    "",
693                    &crate::cli::Page {
694                        offset: 0,
695                        limit: 1,
696                        all: false,
697                    },
698                )
699                .unwrap();
700            assert_eq!(total, 2);
701            assert_eq!(
702                page[0].guid.as_deref(),
703                Some(if expected.contains("01-01") {
704                    "two"
705                } else {
706                    "one"
707                })
708            );
709        }
710    }
711    #[test]
712    fn atom_text_constructs_preserve_literal_markup() {
713        for (kind, content) in [
714            ("", "Show &lt;test&gt; &amp;lt;literal&amp;gt;"),
715            (
716                r#" type="text""#,
717                "Show &lt;test&gt; &amp;lt;literal&amp;gt;",
718            ),
719            (r#" type="text""#, "<![CDATA[Show <test> &lt;literal&gt;]]>"),
720            (
721                r#" type="html""#,
722                "&lt;b&gt;Show&lt;/b&gt; &amp;lt;test&amp;gt; &amp;amp;lt;literal&amp;amp;gt;",
723            ),
724            (
725                r#" type="xhtml""#,
726                r#"<div xmlns="http://www.w3.org/1999/xhtml"><b>Show</b> &lt;test&gt; &amp;lt;literal&amp;gt;</div>"#,
727            ),
728        ] {
729            let p = parse_xml(&format!(
730                r#"<feed xmlns="http://www.w3.org/2005/Atom">
731                <title{kind}>{content}</title><subtitle{kind}>{content}</subtitle>
732                <entry><id>one</id><title{kind}>{content}</title>
733                <summary{kind}>{content}</summary>
734                <link rel="enclosure" href="one.mp3" type="audio/mpeg"/>
735                </entry></feed>"#,
736            ))
737            .unwrap();
738            let expected = "Show <test> &lt;literal&gt;";
739            assert_eq!(p.feed.title, expected, "{kind}: {content}");
740            assert_eq!(p.feed.description, expected);
741            assert_eq!(p.episodes[0].title, expected);
742            assert_eq!(p.episodes[0].description, expected);
743        }
744    }
745    #[test]
746    fn malformed_external_entities_and_missing_audio_are_rejected() {
747        for xml in [
748            "<!DOCTYPE rss SYSTEM 'http://bad.test/dtd'><rss/>",
749            "<rss><channel><title>x</title><item><enclosure url='file:///etc/passwd'/></item></channel></rss>",
750            "<rss><channel><title>x</title><item><enclosure url='https://example.test/a'/></channel>",
751            "<html><title>x</title></html>",
752        ] {
753            assert!(parse_xml(xml).is_err(), "{xml}");
754        }
755        let xml = format!("<rss>{}</rss>", "<a>".repeat(65));
756        assert!(parse_xml(&xml).is_err());
757    }
758}