@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-db/src/requests/availability.rs

@@ -0,0 +1,211 @@
+//! What the library already holds for a requested title.
+
+use rusqlite::{params, Connection, OptionalExtension};
+
+/// `video` items count: enrichment resolves both against TMDB's movie namespace.
+/// Joined back to `items` so a stale core row for a deleted item never matches.
+pub fn movie_item_by_tmdb(conn: &Connection, tmdb_id: u64) -> rusqlite::Result<Option<String>> {
+    conn.query_row(
+        "SELECT c.subject_id FROM metadata_core c JOIN items i ON i.id = c.subject_id \
+         WHERE c.subject_kind = 'item' AND c.tmdb_id = ?1 AND i.kind IN ('movie', 'video') LIMIT 1",
+        params![tmdb_id as i64],
+        |r| r.get(0),
+    )
+    .optional()
+}
+
+pub fn show_by_tmdb(conn: &Connection, tmdb_id: u64) -> rusqlite::Result<Option<String>> {
+    conn.query_row(
+        "SELECT c.subject_id FROM metadata_core c JOIN shows s ON s.id = c.subject_id \
+         WHERE c.subject_kind = 'show' AND c.tmdb_id = ?1 LIMIT 1",
+        params![tmdb_id as i64],
+        |r| r.get(0),
+    )
+    .optional()
+}
+
+/// One physical file backing a catalog item, with what an upgrade needs to
+/// decide whether a new release actually supersedes it.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LibraryFile {
+    pub path: String,
+    pub item_id: String,
+    pub edition: Option<String>,
+    pub spans_episodes: bool,
+}
+
+const SPANS_EPISODES: &str = "i.episode_end IS NOT NULL AND i.episode_end > i.episode";
+
+fn library_file(row: &rusqlite::Row<'_>) -> rusqlite::Result<LibraryFile> {
+    Ok(LibraryFile {
+        path: row.get(0)?,
+        item_id: row.get(1)?,
+        edition: row.get(2)?,
+        spans_episodes: row.get(3)?,
+    })
+}
+
+/// The files backing a movie, by TMDB id, restricted to one library when
+/// `library` is set. Candidates for what an upgrade replaces: the caller still
+/// has to match the edition, since one item holds every cut of a title.
+pub fn movie_files_by_tmdb(
+    conn: &Connection,
+    tmdb_id: u64,
+    library: Option<&str>,
+) -> rusqlite::Result<Vec<LibraryFile>> {
+    let mut stmt = conn.prepare(&format!(
+        "SELECT f.abs_path, f.item_id, f.edition, {SPANS_EPISODES} FROM files f \
+         JOIN items i ON i.id = f.item_id \
+         JOIN metadata_core c ON c.subject_id = i.id AND c.subject_kind = 'item' \
+         WHERE c.tmdb_id = ?1 AND i.kind IN ('movie', 'video') \
+           AND (?2 IS NULL OR i.library = ?2)"
+    ))?;
+    let rows = stmt.query_map(params![tmdb_id as i64, library], library_file)?;
+    rows.collect()
+}
+
+/// The files backing one episode of a show, restricted to one library when
+/// `library` is set. A file that holds a run of episodes is reported with
+/// `spans_episodes`, since it answers for every episode in the run and not just
+/// the one asked for.
+pub fn episode_files(
+    conn: &Connection,
+    show_id: &str,
+    season: u32,
+    episode: u32,
+    library: Option<&str>,
+) -> rusqlite::Result<Vec<LibraryFile>> {
+    let mut stmt = conn.prepare(&format!(
+        "SELECT f.abs_path, f.item_id, f.edition, {SPANS_EPISODES} FROM files f \
+         JOIN items i ON i.id = f.item_id \
+         WHERE i.show_id = ?1 AND i.season = ?2 AND i.episode = ?3 \
+           AND (?4 IS NULL OR i.library = ?4)"
+    ))?;
+    let rows = stmt.query_map(params![show_id, season, episode, library], library_file)?;
+    rows.collect()
+}
+
+pub fn episodes_present(conn: &Connection, show_id: &str) -> rusqlite::Result<Vec<(u32, u32)>> {
+    let mut stmt = conn.prepare(
+        "SELECT DISTINCT season, episode FROM items \
+         WHERE show_id = ?1 AND season IS NOT NULL AND episode IS NOT NULL",
+    )?;
+    let rows = stmt.query_map(params![show_id], |r| Ok((r.get(0)?, r.get(1)?)))?;
+    rows.collect()
+}
+
+/// One episode of a show the library actually holds: which item it is, and how
+/// good the copy is. What the request page needs to link to a file and say what
+/// a re-grab would be replacing.
+#[derive(Debug, Clone)]
+pub struct EpisodeOnDisk {
+    pub season: u32,
+    pub episode: u32,
+    pub item_id: String,
+    pub codec: Option<String>,
+    pub width: Option<u32>,
+    pub height: Option<u32>,
+    pub hdr: bool,
+    pub bit_depth: Option<u32>,
+    pub duration_ms: Option<i64>,
+}
+
+/// Every episode of `show_id` on disk. One row per season/episode: a duplicate
+/// keeps the widest copy, since that is the one a viewer gets.
+pub fn episodes_on_disk(conn: &Connection, show_id: &str) -> rusqlite::Result<Vec<EpisodeOnDisk>> {
+    let mut stmt = conn.prepare(
+        "SELECT season, episode, id, v_codec, v_width, v_height, v_hdr, v_bit_depth, duration_ms \
+         FROM items \
+         WHERE show_id = ?1 AND season IS NOT NULL AND episode IS NOT NULL \
+         ORDER BY season, episode, v_width DESC",
+    )?;
+    let rows = stmt.query_map(params![show_id], |r| {
+        Ok(EpisodeOnDisk {
+            season: r.get(0)?,
+            episode: r.get(1)?,
+            item_id: r.get(2)?,
+            codec: r.get(3)?,
+            width: r.get(4)?,
+            height: r.get(5)?,
+            hdr: r.get::<_, Option<i64>>(6)?.unwrap_or(0) != 0,
+            bit_depth: r.get(7)?,
+            duration_ms: r.get(8)?,
+        })
+    })?;
+    let mut out: Vec<EpisodeOnDisk> = Vec::new();
+    for row in rows {
+        let row = row?;
+        if out
+            .last()
+            .is_some_and(|p| p.season == row.season && p.episode == row.episode)
+        {
+            continue;
+        }
+        out.push(row);
+    }
+    Ok(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::requests::tests::*;
+
+    #[test]
+    fn availability_lookup_matches_metadata_tmdb_id() {
+        let p = pool();
+        let conn = p.get().unwrap();
+        seed_library(&conn);
+        insert_movie_item(&conn, "m1", 603);
+        assert_eq!(
+            movie_item_by_tmdb(&conn, 603).unwrap().as_deref(),
+            Some("m1")
+        );
+        assert_eq!(movie_item_by_tmdb(&conn, 604).unwrap(), None);
+        // An item with no metadata_core row has no tmdb_id to seek.
+        conn.execute(
+            "INSERT INTO items (id, kind, title, container, library, added_at) \
+             VALUES ('m2','movie','U','mkv','lib1','now')",
+            [],
+        )
+        .unwrap();
+        assert_eq!(movie_item_by_tmdb(&conn, 0).unwrap(), None);
+    }
+
+    #[test]
+    fn episodes_on_disk_reports_one_row_per_episode_with_its_media() {
+        let p = pool();
+        let conn = p.get().unwrap();
+        seed_library(&conn);
+        conn.execute(
+            "INSERT INTO shows (id,library,title,added_at) VALUES ('s1','lib1','Show','now')",
+            [],
+        )
+        .unwrap();
+        // Two files for S01E01: the widest wins, since that is what a viewer gets.
+        for (id, season, episode, width) in
+            [("i1", 1, 1, 1920), ("i2", 1, 1, 3840), ("i3", 1, 2, 1280)]
+        {
+            conn.execute(
+                &format!(
+                    "INSERT INTO items (id,kind,title,container,library,show_id,season,episode,v_codec,v_width,v_height,v_hdr,duration_ms,added_at) \
+                     VALUES ('{id}','episode','E','mkv','lib1','s1',{season},{episode},'hevc',{width},1080,1,600000,'now')"
+                ),
+                [],
+            )
+            .unwrap();
+        }
+
+        let rows = episodes_on_disk(&conn, "s1").unwrap();
+        assert_eq!(rows.len(), 2, "one row per episode, not per file");
+        let e1 = rows.iter().find(|r| r.episode == 1).unwrap();
+        assert_eq!(e1.width, Some(3840), "the widest copy of the two");
+        assert_eq!(e1.codec.as_deref(), Some("hevc"));
+        assert!(e1.hdr);
+        assert_eq!(e1.duration_ms, Some(600_000));
+        assert_eq!(
+            rows.iter().find(|r| r.episode == 2).unwrap().width,
+            Some(1280)
+        );
+    }
+}

package/rust/kroma-db/src/requests/calendar.rs

@@ -0,0 +1,221 @@
+//! Reading the ledger as a calendar: what is coming, and what is still missing.
+
+use rusqlite::{params, Connection, Row};
+
+use kroma_domain::{CalendarEntry, RequestKind};
+
+// Callers append their own `WHERE`/`ORDER BY`/`LIMIT` and map rows with `row_to_calendar_entry`.
+const CALENDAR_SELECT: &str =
+    "SELECT w.request_id, w.tmdb_id, r.kind, w.title, w.year, r.poster_url, \
+                w.season, w.episode, w.air_date, w.status \
+         FROM wanted w JOIN requests r ON r.id = w.request_id";
+
+fn row_to_calendar_entry(r: &Row) -> rusqlite::Result<CalendarEntry> {
+    let kind: String = r.get(2)?;
+    Ok(CalendarEntry {
+        request_id: Some(r.get(0)?),
+        tmdb_id: r.get::<_, i64>(1)? as u64,
+        kind: RequestKind::parse(&kind).unwrap_or(RequestKind::Movie),
+        title: r.get(3)?,
+        year: r.get(4)?,
+        poster_url: r.get(5)?,
+        season: r.get(6)?,
+        episode: r.get(7)?,
+        air_date: r.get(8)?,
+        status: r.get(9)?,
+    })
+}
+
+/// Future-dated wanted rows, soonest first. `requester` scopes to one user's
+/// requests; `None` is the manager view spanning every request.
+pub fn upcoming_calendar(
+    conn: &Connection,
+    today: &str,
+    requester: Option<&str>,
+    limit: usize,
+) -> rusqlite::Result<Vec<CalendarEntry>> {
+    let mut stmt = conn.prepare(&format!(
+        "{CALENDAR_SELECT} \
+         WHERE w.air_date IS NOT NULL AND w.air_date > ?1 \
+           AND w.status IN ('wanted', 'grabbed') \
+           AND r.status NOT IN ('denied', 'failed') \
+           AND (?2 IS NULL OR r.requested_by = ?2) \
+         ORDER BY w.air_date ASC, r.title ASC LIMIT ?3"
+    ))?;
+    let rows = stmt.query_map(
+        params![today, requester, limit as i64],
+        row_to_calendar_entry,
+    )?;
+    rows.collect()
+}
+
+/// The inverse of [`upcoming_calendar`]: aired-or-undated rows still `wanted`.
+/// `requester` scopes to one user's requests; `None` spans all.
+pub fn missing_items(
+    conn: &Connection,
+    today: &str,
+    requester: Option<&str>,
+    limit: usize,
+) -> rusqlite::Result<Vec<CalendarEntry>> {
+    let mut stmt = conn.prepare(&format!(
+        "{CALENDAR_SELECT} \
+         WHERE w.status = 'wanted' AND (w.air_date IS NULL OR w.air_date <= ?1) \
+           AND r.status NOT IN ('denied', 'failed') \
+           AND (?2 IS NULL OR r.requested_by = ?2) \
+         ORDER BY r.title ASC, w.season ASC, w.episode ASC LIMIT ?3"
+    ))?;
+    let rows = stmt.query_map(
+        params![today, requester, limit as i64],
+        row_to_calendar_entry,
+    )?;
+    rows.collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::requests::tests::*;
+    use crate::requests::{insert_request, insert_wanted, replace_wanted, WantedRow};
+    use kroma_domain::RequestStatus;
+
+    #[test]
+    fn missing_items_lists_aired_open_rows_only() {
+        let p = pool();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 1396, None), 1000).unwrap();
+        let mk = |id: &str, episode: u32, air: Option<&str>, status: &str| WantedRow {
+            id: id.into(),
+            request_id: "r1".into(),
+            kind: "episode".into(),
+            tmdb_id: 1396,
+            imdb_id: None,
+            title: "T".into(),
+            year: None,
+            season: Some(1),
+            episode: Some(episode),
+            air_date: air.map(str::to_string),
+            status: status.into(),
+            last_search_at: None,
+        };
+        replace_wanted(
+            &p,
+            "r1",
+            &[
+                mk("w-aired", 1, Some("2020-01-01"), "wanted"),
+                mk("w-future", 2, Some("2999-01-01"), "wanted"),
+                mk("w-grabbed", 3, Some("2020-01-01"), "grabbed"),
+                mk("w-available", 4, Some("2020-01-01"), "available"),
+                mk("w-undated", 5, None, "wanted"),
+            ],
+            1000,
+        )
+        .unwrap();
+
+        let conn = p.get().unwrap();
+        let missing = missing_items(&conn, "2026-07-05", None, 50).unwrap();
+        let mut eps: Vec<u32> = missing.iter().filter_map(|e| e.episode).collect();
+        eps.sort_unstable();
+        assert_eq!(eps, vec![1, 5]);
+        assert!(missing_items(&conn, "2026-07-05", Some("someone-else"), 50)
+            .unwrap()
+            .is_empty());
+    }
+
+    #[test]
+    fn the_calendar_shows_only_what_is_still_coming() {
+        let pool = pool();
+        req_by(&pool, "r-1", 1, RequestStatus::Approved, Some("ana"));
+
+        insert_wanted(
+            &pool,
+            &[
+                wanted_row("w-future", "r-1", Some("2030-01-01"), "wanted"),
+                wanted_row("w-past", "r-1", Some("2020-01-01"), "wanted"),
+                wanted_row("w-undated", "r-1", None, "wanted"),
+                wanted_row("w-done", "r-1", Some("2030-02-01"), "available"),
+                wanted_row("w-grabbed", "r-1", Some("2030-03-01"), "grabbed"),
+            ],
+            1_000,
+        )
+        .unwrap();
+
+        let conn = pool.get().unwrap();
+        let out = upcoming_calendar(&conn, "2026-01-01", None, 50).unwrap();
+        let dates: Vec<&str> = out.iter().filter_map(|e| e.air_date.as_deref()).collect();
+        assert_eq!(dates, ["2030-01-01", "2030-03-01"], "{out:?}");
+        assert!(dates.windows(2).all(|w| w[0] <= w[1]));
+    }
+
+    #[test]
+    fn a_denied_request_drops_off_the_calendar_entirely() {
+        let pool = pool();
+        req_by(&pool, "r-denied", 1, RequestStatus::Denied, Some("ana"));
+        req_by(&pool, "r-live", 2, RequestStatus::Approved, Some("ana"));
+        insert_wanted(
+            &pool,
+            &[
+                wanted_row("w-dead", "r-denied", Some("2030-01-01"), "wanted"),
+                wanted_row("w-live", "r-live", Some("2030-01-02"), "wanted"),
+            ],
+            1_000,
+        )
+        .unwrap();
+
+        let conn = pool.get().unwrap();
+        let out = upcoming_calendar(&conn, "2026-01-01", None, 50).unwrap();
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].request_id.as_deref(), Some("r-live"));
+    }
+
+    #[test]
+    fn the_calendar_can_be_scoped_to_one_account_or_span_them_all() {
+        let pool = pool();
+        req_by(&pool, "r-ana", 1, RequestStatus::Approved, Some("ana"));
+        req_by(&pool, "r-bo", 2, RequestStatus::Approved, Some("bo"));
+        insert_wanted(
+            &pool,
+            &[
+                wanted_row("w-a", "r-ana", Some("2030-01-01"), "wanted"),
+                wanted_row("w-b", "r-bo", Some("2030-01-02"), "wanted"),
+            ],
+            1_000,
+        )
+        .unwrap();
+
+        let conn = pool.get().unwrap();
+        assert_eq!(
+            upcoming_calendar(&conn, "2026-01-01", Some("ana"), 50)
+                .unwrap()
+                .len(),
+            1
+        );
+        assert_eq!(
+            upcoming_calendar(&conn, "2026-01-01", None, 50)
+                .unwrap()
+                .len(),
+            2
+        );
+    }
+
+    #[test]
+    fn the_calendar_honours_its_limit() {
+        let pool = pool();
+        req_by(&pool, "r-1", 1, RequestStatus::Approved, Some("ana"));
+        let rows: Vec<WantedRow> = (1..=5)
+            .map(|n| {
+                wanted_row(
+                    &format!("w-{n}"),
+                    "r-1",
+                    Some(&format!("2030-01-0{n}")),
+                    "wanted",
+                )
+            })
+            .collect();
+        insert_wanted(&pool, &rows, 1_000).unwrap();
+
+        let conn = pool.get().unwrap();
+        let out = upcoming_calendar(&conn, "2026-01-01", None, 2).unwrap();
+        assert_eq!(out.len(), 2);
+        assert_eq!(out[0].air_date.as_deref(), Some("2030-01-01"));
+        assert_eq!(out[1].air_date.as_deref(), Some("2030-01-02"));
+    }
+}

package/rust/kroma-db/src/requests/gaps.rs

@@ -0,0 +1,213 @@
+//! Library-scan gaps: aired episodes a show on disk is missing.
+
+use anyhow::Result;
+use rusqlite::{params, Connection};
+
+use crate::pool::Pool;
+use kroma_domain::{CalendarEntry, RequestKind};
+
+/// Replace one show's library-scan gaps (aired TMDB episodes not on disk) in one
+/// transaction. `rows` = (season, episode, air_date); empty clears the show.
+pub fn replace_show_gaps(
+    pool: &Pool,
+    show_id: &str,
+    tmdb_id: u64,
+    title: &str,
+    poster_url: Option<&str>,
+    rows: &[(u32, u32, Option<String>)],
+    now_ms: i64,
+) -> Result<()> {
+    let mut conn = pool.get()?;
+    let tx = conn.transaction()?;
+    tx.execute(
+        "DELETE FROM library_gaps WHERE show_id = ?1",
+        params![show_id],
+    )?;
+    {
+        let mut stmt = tx.prepare(
+            "INSERT INTO library_gaps (show_id, tmdb_id, title, poster_url, season, episode, air_date, detected_at) \
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
+        )?;
+        for (season, episode, air_date) in rows {
+            stmt.execute(params![
+                show_id,
+                tmdb_id as i64,
+                title,
+                poster_url,
+                season,
+                episode,
+                air_date,
+                now_ms
+            ])?;
+        }
+    }
+    tx.commit()?;
+    Ok(())
+}
+
+/// Library-scan gaps as [`CalendarEntry`] with `request_id = None` — they are not
+/// requests yet. Shows with an open request for the same tmdb id are excluded,
+/// since that request's ledger already tracks them.
+pub fn library_gaps_list(conn: &Connection, limit: usize) -> rusqlite::Result<Vec<CalendarEntry>> {
+    let mut stmt = conn.prepare(
+        "SELECT g.tmdb_id, g.title, g.poster_url, g.season, g.episode, g.air_date \
+         FROM library_gaps g \
+         WHERE NOT EXISTS ( \
+             SELECT 1 FROM requests r \
+             WHERE r.tmdb_id = g.tmdb_id AND r.kind = 'show' \
+               AND r.status NOT IN ('denied', 'failed') \
+         ) \
+         ORDER BY g.title ASC, g.season ASC, g.episode ASC LIMIT ?1",
+    )?;
+    let rows = stmt.query_map(params![limit as i64], |r| {
+        Ok(CalendarEntry {
+            request_id: None,
+            tmdb_id: r.get::<_, i64>(0)? as u64,
+            kind: RequestKind::Show,
+            title: r.get(1)?,
+            year: None,
+            poster_url: r.get(2)?,
+            season: r.get(3)?,
+            episode: r.get(4)?,
+            air_date: r.get(5)?,
+            status: "missing".into(),
+        })
+    })?;
+    rows.collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::requests::tests::*;
+    use crate::requests::{episodes_present, insert_request, set_request_status};
+    use kroma_domain::RequestStatus;
+
+    #[test]
+    fn replace_show_gaps_rewrites_only_that_show() {
+        let p = pool();
+        seed_show(&p, "s1");
+        seed_show(&p, "s2");
+        replace_show_gaps(&p, "s1", 1, "Alpha", None, &[gap(1, 1, "2020-01-01")], 1).unwrap();
+        replace_show_gaps(&p, "s2", 2, "Beta", None, &[gap(1, 1, "2020-01-01")], 1).unwrap();
+
+        replace_show_gaps(&p, "s1", 1, "Alpha", None, &[gap(2, 5, "2021-02-02")], 2).unwrap();
+        let conn = p.get().unwrap();
+        let rows = library_gaps_list(&conn, 50).unwrap();
+        assert_eq!(rows.len(), 2);
+        let alpha = rows.iter().find(|r| r.title == "Alpha").unwrap();
+        assert_eq!((alpha.season, alpha.episode), (Some(2), Some(5)));
+        assert!(rows.iter().any(|r| r.title == "Beta"));
+    }
+
+    #[test]
+    fn replace_show_gaps_with_no_rows_clears_a_now_complete_show() {
+        let p = pool();
+        seed_show(&p, "s1");
+        replace_show_gaps(&p, "s1", 1, "Alpha", None, &[gap(1, 1, "2020-01-01")], 1).unwrap();
+        replace_show_gaps(&p, "s1", 1, "Alpha", None, &[], 2).unwrap();
+        assert!(library_gaps_list(&p.get().unwrap(), 50).unwrap().is_empty());
+    }
+
+    #[test]
+    fn library_gaps_list_reports_gaps_as_unrequested_missing_rows() {
+        let p = pool();
+        seed_show(&p, "s1");
+        replace_show_gaps(
+            &p,
+            "s1",
+            42,
+            "Alpha",
+            Some("/p.jpg"),
+            &[gap(1, 3, "2020-01-01")],
+            1,
+        )
+        .unwrap();
+
+        let rows = library_gaps_list(&p.get().unwrap(), 50).unwrap();
+        assert_eq!(rows.len(), 1);
+        let r = &rows[0];
+        assert!(r.request_id.is_none());
+        assert_eq!(r.status, "missing");
+        assert_eq!(r.tmdb_id, 42);
+        assert_eq!(r.poster_url.as_deref(), Some("/p.jpg"));
+        assert_eq!(r.air_date.as_deref(), Some("2020-01-01"));
+    }
+
+    #[test]
+    fn library_gaps_list_hides_a_show_that_already_has_an_open_request() {
+        let p = pool();
+        seed_show(&p, "s1");
+        replace_show_gaps(&p, "s1", 42, "Alpha", None, &[gap(1, 1, "2020-01-01")], 1).unwrap();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 42, None), 1).unwrap();
+
+        assert!(library_gaps_list(&p.get().unwrap(), 50).unwrap().is_empty());
+    }
+
+    #[test]
+    fn library_gaps_list_shows_a_gap_again_once_its_request_is_denied() {
+        let p = pool();
+        seed_show(&p, "s1");
+        replace_show_gaps(&p, "s1", 42, "Alpha", None, &[gap(1, 1, "2020-01-01")], 1).unwrap();
+        insert_request(&p, &new_req("r1", RequestKind::Show, 42, None), 1).unwrap();
+        assert!(library_gaps_list(&p.get().unwrap(), 50).unwrap().is_empty());
+
+        set_request_status(&p, "r1", RequestStatus::Denied, None, None, 2).unwrap();
+        assert_eq!(library_gaps_list(&p.get().unwrap(), 50).unwrap().len(), 1);
+    }
+
+    #[test]
+    fn library_gaps_list_ignores_a_movie_request_for_the_same_tmdb_id() {
+        let p = pool();
+        seed_show(&p, "s1");
+        replace_show_gaps(&p, "s1", 42, "Alpha", None, &[gap(1, 1, "2020-01-01")], 1).unwrap();
+        // tmdb ids are unique only within a kind.
+        insert_request(&p, &new_req("r1", RequestKind::Movie, 42, None), 1).unwrap();
+        assert_eq!(library_gaps_list(&p.get().unwrap(), 50).unwrap().len(), 1);
+    }
+
+    #[test]
+    fn library_gaps_list_sorts_by_title_then_episode_and_honours_the_limit() {
+        let p = pool();
+        seed_show(&p, "s1");
+        seed_show(&p, "s2");
+        replace_show_gaps(&p, "s2", 2, "Beta", None, &[gap(1, 1, "2020-01-01")], 1).unwrap();
+        replace_show_gaps(
+            &p,
+            "s1",
+            1,
+            "Alpha",
+            None,
+            &[gap(2, 1, "2020-01-01"), gap(1, 2, "2020-01-01")],
+            1,
+        )
+        .unwrap();
+
+        let conn = p.get().unwrap();
+        let rows = library_gaps_list(&conn, 50).unwrap();
+        let seen: Vec<(String, Option<u32>, Option<u32>)> = rows
+            .iter()
+            .map(|r| (r.title.clone(), r.season, r.episode))
+            .collect();
+        assert_eq!(
+            seen,
+            vec![
+                ("Alpha".into(), Some(1), Some(2)),
+                ("Alpha".into(), Some(2), Some(1)),
+                ("Beta".into(), Some(1), Some(1)),
+            ]
+        );
+        assert_eq!(library_gaps_list(&conn, 2).unwrap().len(), 2);
+    }
+
+    #[test]
+    fn the_calendar_and_episode_readers_error_when_their_tables_are_gone() {
+        let pool = pool();
+        let conn = pool.get().unwrap();
+        conn.execute_batch("DROP TABLE library_gaps; DROP TABLE items")
+            .unwrap();
+
+        assert!(library_gaps_list(&conn, 10).is_err());
+        assert!(episodes_present(&conn, "s1").is_err());
+    }
+}