//! Matching an RSS result against the wanted list (`DESIGN.md` §6.2). //! //! RSS is an empty-query feed: every item is offered to the whole wanted list //! and nothing about the query says which title an item is for. That makes a //! false positive expensive — it grabs the wrong film — and a false negative //! nearly free, because the feed is read again ten minutes later and the //! targeted search still runs. So every rule here is deliberately strict: //! //! - an ID the tracker itself supplied beats anything read off the name, //! except a season or episode tag in the name, which makes the release a //! TV one whatever id came with it; and an ID that matches nothing wanted //! ends the comparison rather than falling back to the title; //! - two supplied IDs that disagree about which title this is are an //! ambiguity like any other, and match nothing; //! - a title match needs the years to agree, and a wanted title with a known //! year is never matched by a release that does not state one; //! - anything that matches two wanted titles matches neither. //! //! The TV side ([`match_episode`]) answers a narrower question about one //! release and one wanted episode: is this its file, or a pack for exactly //! the season holding it? use crate::{EpisodeId, MovieId}; use arr_parse::{EpisodeClaim, NameClaims}; /// A wanted title, in the shape matching needs. #[derive(Clone, Debug, Eq, PartialEq)] pub struct WantedMovie { pub id: MovieId, /// TMDB id, compared against the one the tracker attached to the item. pub tmdb_id: Option, /// `IMDb` id as TMDB spells it (`tt0317248`), compared against the one /// the tracker attached to the item. Absent until the metadata refresh /// has run, and for the titles TMDB knows no `IMDb` id for. pub imdb_id: Option, pub title: String, pub year: Option, } /// What tied a release to a wanted title. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum MatchKind { /// The tracker supplied a TMDB id and it is one of ours. TmdbId, /// The tracker supplied an `IMDb` id and it is one of ours. ImdbId, /// The parsed release name and the wanted title agree, years included. TitleAndYear, } /// The ids a tracker attached to a feed item, as it spelled them. /// /// Both are optional and independent: a definition emits whichever its /// tracker carries, and `imdbid` is the one most of them carry (§6.2). #[derive(Clone, Debug, Default, Eq, PartialEq)] pub struct ReleaseIds { pub tmdb_id: Option, pub imdb_id: Option, } /// One wanted title an RSS item was matched to. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct MovieMatch { pub movie: MovieId, pub kind: MatchKind, } /// The wanted title an RSS item belongs to, or `None` when nothing matches /// conservatively. /// /// `ids` are what the indexer attached to the item, not anything inferred /// from the name; `claims` is the parsed release name. #[must_use] pub fn match_movie( wanted: &[WantedMovie], ids: &ReleaseIds, claims: &NameClaims, ) -> Option { // A season or episode tag makes this a TV release, whatever the title // or the tracker-supplied id says. Movies are the only thing RSS grabs // today (§13, phase 4), and trackers do mislabel ids. if claims.episode.is_some() { return None; } let imdb_id = ids.imdb_id.as_deref().and_then(imdb_key); if ids.tmdb_id.is_some() || imdb_id.is_some() { // A title matched by both ids is still one title, so each wanted // title is offered at most once and only a genuine disagreement // between the two ids reads as an ambiguity. return unique(wanted.iter().filter_map(|movie| { let kind = if ids.tmdb_id.is_some() && movie.tmdb_id == ids.tmdb_id { MatchKind::TmdbId } else if imdb_id.is_some() && movie.imdb_id.as_deref().and_then(imdb_key) == imdb_id { MatchKind::ImdbId } else { return None; }; Some(MovieMatch { movie: movie.id, kind, }) })); } let title = match_key(claims.title.as_deref()?); if title.is_empty() { return None; } unique( wanted .iter() .filter(|movie| { match_key(&movie.title) == title && years_agree(movie.year, claims.year) }) .map(|movie| MovieMatch { movie: movie.id, kind: MatchKind::TitleAndYear, }), ) } /// The digits of an `IMDb` title id, or `None` when the string is not one. /// /// Trackers spell the same id several ways: TMDB and most feeds write /// `tt0317248`, some Torznab definitions emit the bare number, and either /// may or may not carry the leading zeros `IMDb` pads to seven digits. All /// of those are the same title, and nothing else is an id at all. fn imdb_key(id: &str) -> Option<&str> { let digits = id.trim(); let digits = digits .strip_prefix("tt") .or_else(|| digits.strip_prefix("TT")) .unwrap_or(digits); if !digits.bytes().all(|byte| byte.is_ascii_digit()) { return None; } // An id of nothing but zeros is a placeholder, not a title. let trimmed = digits.trim_start_matches('0'); (!trimmed.is_empty()).then_some(trimmed) } /// A release with no year matches only a title that has none either: films /// share titles across decades, and the remake is not the one that is wanted. fn years_agree(wanted: Option, release: Option) -> bool { match (wanted, release) { (Some(wanted), Some(release)) => wanted == release, (None, None) => true, _ => false, } } /// Two matches are an ambiguity, and an ambiguity is not a match. fn unique(mut matches: impl Iterator) -> Option { let first = matches.next()?; matches.next().is_none().then_some(first) } /// One wanted episode, in the shape matching needs. The ids are the /// series', not the episode's: trackers attach them to the show. #[derive(Clone, Debug, Eq, PartialEq)] pub struct WantedEpisode { pub id: EpisodeId, /// TMDB id of the series, compared against the one the tracker attached /// to the item. pub tmdb_id: Option, /// `IMDb` id of the series, as TMDB spells it (`tt11301866`). Absent /// until the metadata refresh has run. pub imdb_id: Option, pub title: String, pub season: u32, pub episode: u32, } /// Which file shape satisfied a wanted episode. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum MatchShape { /// A release holding exactly this one episode. SingleEpisode, /// A pack for exactly the season this episode belongs to. SeasonPack, } /// What tied a release to a wanted episode, and what it is. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct EpisodeMatch { pub episode: EpisodeId, pub kind: MatchKind, pub shape: MatchShape, } /// Whether a release satisfies one wanted episode, and as what. /// /// Identity is decided as [`match_movie`] decides it — a supplied id that /// matches nothing wanted ends the comparison, a junk id falls through to /// the title — except the title lane compares the series title alone. TV /// release names rarely state a year at all, and when they do it is the /// season's air year rather than the series', so the year rule films live /// by would starve this lane; exact title comparison is what keeps two /// series sharing a word apart. /// /// Only two shapes satisfy anything: a file holding exactly this episode /// and a pack for exactly its season. Multi-episode files and multi-season /// packs are left to the operator, who reaches them through the episode and /// season decks (§6.2). #[must_use] pub fn match_episode( wanted: &WantedEpisode, ids: &ReleaseIds, claims: &NameClaims, ) -> Option { let imdb_id = ids.imdb_id.as_deref().and_then(imdb_key); let kind = if ids.tmdb_id.is_some() || imdb_id.is_some() { if ids.tmdb_id.is_some() && wanted.tmdb_id == ids.tmdb_id { MatchKind::TmdbId } else if imdb_id.is_some() && wanted.imdb_id.as_deref().and_then(imdb_key) == imdb_id { MatchKind::ImdbId } else { return None; } } else { let title = match_key(claims.title.as_deref()?); if title.is_empty() || title != match_key(&wanted.title) { return None; } MatchKind::TitleAndYear }; // Whatever the name or id says, nothing without a TV tag holds an // episode, and no daily-show air date is a numbered one. let claim = claims.episode.as_ref()?; let shape = if is_this_seasons_pack(claim, wanted.season) { MatchShape::SeasonPack } else if is_single_episode(claim, wanted.season, wanted.episode) { MatchShape::SingleEpisode } else { return None; }; Some(EpisodeMatch { episode: wanted.id, kind, shape, }) } /// A pack for exactly this season. Multi-season packs are never selected /// automatically: they drag other seasons in with them. fn is_this_seasons_pack(claim: &EpisodeClaim, season: u32) -> bool { match claim { EpisodeClaim::Season { season: claimed } => *claimed == season, EpisodeClaim::Seasons { first, last } => first == last && *first == season, EpisodeClaim::Episodes { .. } | EpisodeClaim::Daily { .. } => false, } } /// A release holding exactly this one episode. Multi-episode files are left /// to manual grabs: two episodes automatically picking the same torrent /// would fight over one `grabs` row. fn is_single_episode(claim: &EpisodeClaim, season: u32, episode: u32) -> bool { matches!( claim, EpisodeClaim::Episodes { episodes, .. } if episodes.len() == 1 ) && claim.covers(season, episode) } /// The form two titles are compared in: lower case, accents folded to ASCII, /// `&` spelled out, and every run of anything else one space. /// /// This absorbs the separators and punctuation a release name loses ("Dune: /// Part Two" against `Dune.Part.Two`) without absorbing a word, so a longer /// or shorter title stays a different title. fn match_key(title: &str) -> String { let mut key = String::with_capacity(title.len()); let mut gap = false; for character in title.chars() { if let Some(folded) = fold(character) { separate(&mut key, &mut gap); key.push_str(folded); } else if character.is_alphanumeric() { separate(&mut key, &mut gap); key.extend(character.to_lowercase()); } else { gap = !key.is_empty(); } } key } fn separate(key: &mut String, gap: &mut bool) { if *gap { key.push(' '); } *gap = false; } /// The ASCII a letter is written as when a tracker cannot spell the accent, /// and the word an `&` is spelled out as. `None` leaves the character to /// [`match_key`], which keeps any other letter or digit as it is. fn fold(character: char) -> Option<&'static str> { Some(match character { '&' => "and", 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' => "a", 'ç' | 'Ç' => "c", 'è' | 'é' | 'ê' | 'ë' | 'È' | 'É' | 'Ê' | 'Ë' => "e", 'ì' | 'í' | 'î' | 'ï' | 'Ì' | 'Í' | 'Î' | 'Ï' => "i", 'ñ' | 'Ñ' => "n", 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | 'ø' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | 'Ø' => "o", 'ù' | 'ú' | 'û' | 'ü' | 'Ù' | 'Ú' | 'Û' | 'Ü' => "u", 'ý' | 'ÿ' | 'Ý' => "y", 'ß' => "ss", 'æ' | 'Æ' => "ae", _ => return None, }) } #[cfg(test)] mod tests { use super::{ match_episode, match_key, match_movie, EpisodeId, EpisodeMatch, MatchKind, MatchShape, MovieMatch, ReleaseIds, WantedEpisode, WantedMovie, }; use crate::MovieId; fn wanted() -> Vec { vec![ WantedMovie { id: MovieId(1), tmdb_id: Some(693_134), imdb_id: Some("tt15239678".to_owned()), title: "Dune: Part Two".to_owned(), year: Some(2024), }, WantedMovie { id: MovieId(2), tmdb_id: Some(438_631), imdb_id: Some("tt1160419".to_owned()), title: "Dune".to_owned(), year: Some(2021), }, WantedMovie { id: MovieId(3), tmdb_id: Some(194), imdb_id: None, title: "Amélie".to_owned(), year: Some(2001), }, ] } fn ids(tmdb_id: Option, imdb_id: Option<&str>) -> ReleaseIds { ReleaseIds { tmdb_id, imdb_id: imdb_id.map(ToOwned::to_owned), } } fn matched(name: &str, tmdb_id: Option) -> Option { match_movie(&wanted(), &ids(tmdb_id, None), &arr_parse::parse(name)) } fn matched_by_imdb(name: &str, imdb_id: &str) -> Option { match_movie( &wanted(), &ids(None, Some(imdb_id)), &arr_parse::parse(name), ) } #[test] fn a_supplied_id_matches_whatever_the_name_says() { assert_eq!( matched("Some.Scene.Name.2024.2160p.WEB-DL", Some(693_134)), Some(MovieMatch { movie: MovieId(1), kind: MatchKind::TmdbId, }) ); } /// The tracker said which film this is and it is not one of ours. Falling /// back to the title here is how a wrong film gets grabbed. #[test] fn a_supplied_id_that_is_not_wanted_ends_the_comparison() { assert_eq!(matched("Dune.Part.Two.2024.2160p.WEB-DL", Some(11)), None); } #[test] fn separators_punctuation_and_accents_do_not_block_a_title_match() { assert_eq!( matched("Dune.Part.Two.2024.2160p.WEB-DL.DDP5.1.Atmos-GROUP", None), Some(MovieMatch { movie: MovieId(1), kind: MatchKind::TitleAndYear, }) ); assert_eq!( matched("Amelie.2001.1080p.BluRay.x264-GROUP", None), Some(MovieMatch { movie: MovieId(3), kind: MatchKind::TitleAndYear, }) ); } /// The near miss: one title is a prefix of the other, same year band, /// same franchise. Nothing here may match. #[test] fn a_near_miss_does_not_match() { assert_eq!(matched("Dune.2024.2160p.WEB-DL-GROUP", None), None); assert_eq!(matched("Dune.Part.One.2021.1080p.WEB-DL", None), None); assert_eq!(matched("Dune.Part.Two.2023.1080p.WEB-DL", None), None); assert_eq!(matched("Dune.Prophecy.2024.1080p.WEB-DL", None), None); } #[test] fn a_release_with_no_year_is_not_matched_to_a_title_that_has_one() { assert_eq!(matched("Dune.Part.Two.2160p.WEB-DL", None), None); } #[test] fn an_episode_tag_is_never_a_movie() { let wanted = vec![WantedMovie { id: MovieId(4), tmdb_id: Some(1), imdb_id: None, title: "Fallout".to_owned(), year: Some(2024), }]; let claims = arr_parse::parse("Fallout.2024.S01E03.1080p.WEB-DL"); assert_eq!(match_movie(&wanted, &ReleaseIds::default(), &claims), None); } /// The same rule on the id lane (#139): trackers mislabel ids, so a /// season or episode tag in the name vetoes an id that matches too. #[test] fn an_episode_tag_beats_a_matching_supplied_id() { let wanted = vec![WantedMovie { id: MovieId(1), tmdb_id: Some(693_134), imdb_id: Some("tt15239678".to_owned()), title: "Dune: Part Two".to_owned(), year: Some(2024), }]; let cases = [ ("Fallout.S01E03.1080p.WEB-DL", &ids(Some(693_134), None)), ("Fallout.S01.1080p.BluRay-GROUP", &ids(Some(693_134), None)), ( "Fallout.2024.S01E03.1080p.WEB-DL", &ids(None, Some("tt15239678")), ), ("Fallout.S01E03.1080p.WEB-DL", &ids(None, Some("15239678"))), ]; for (name, release_ids) in cases { assert_eq!( match_movie(&wanted, release_ids, &arr_parse::parse(name)), None, "{name}" ); } } #[test] fn two_wanted_titles_that_both_match_are_an_ambiguity() { let wanted = vec![ WantedMovie { id: MovieId(5), tmdb_id: Some(1), imdb_id: None, title: "The Thing".to_owned(), year: Some(1982), }, WantedMovie { id: MovieId(6), tmdb_id: Some(2), imdb_id: None, title: "The Thing".to_owned(), year: Some(1982), }, ]; let claims = arr_parse::parse("The.Thing.1982.1080p.BluRay"); assert_eq!(match_movie(&wanted, &ReleaseIds::default(), &claims), None); } #[test] fn ampersands_and_spelling_agree() { assert_eq!(match_key("Fast & Furious"), "fast and furious"); assert_eq!(match_key("Fast and Furious"), "fast and furious"); assert_eq!(match_key(" Dune: Part Two "), "dune part two"); } #[test] fn a_supplied_imdb_id_matches_whatever_the_name_says() { assert_eq!( matched_by_imdb("Some.Scene.Name.2024.2160p.WEB-DL", "tt15239678"), Some(MovieMatch { movie: MovieId(1), kind: MatchKind::ImdbId, }) ); } /// Torznab definitions spell the same id three ways. All of them are the /// one title, and matching none of them is how the id lane stays unused. #[test] fn an_imdb_id_matches_however_the_tracker_spells_it() { for spelling in ["tt15239678", "15239678", "tt0015239678", " tt15239678 "] { assert_eq!( matched_by_imdb("Some.Scene.Name.2024.2160p.WEB-DL", spelling), Some(MovieMatch { movie: MovieId(1), kind: MatchKind::ImdbId, }), "{spelling}" ); } } #[test] fn a_supplied_imdb_id_that_is_not_wanted_ends_the_comparison() { assert_eq!( matched_by_imdb("Dune.Part.Two.2024.2160p.WEB-DL", "tt0000001"), None ); } /// A placeholder or a non-id is no id at all, so the title lane still runs. #[test] fn a_junk_imdb_id_falls_through_to_the_title() { for junk in ["", "tt", "tt0000000", "0", "n/a"] { assert_eq!( matched_by_imdb("Dune.Part.Two.2024.2160p.WEB-DL", junk), Some(MovieMatch { movie: MovieId(1), kind: MatchKind::TitleAndYear, }), "{junk}" ); } } /// Both ids on the same title is one match, not an ambiguity, and the /// TMDB id is what reports it. #[test] fn two_ids_that_agree_are_one_match() { assert_eq!( match_movie( &wanted(), &ids(Some(693_134), Some("tt15239678")), &arr_parse::parse("Some.Scene.Name.2024.2160p.WEB-DL"), ), Some(MovieMatch { movie: MovieId(1), kind: MatchKind::TmdbId, }) ); } /// The tracker named two different films. Picking either is a coin toss /// on which one gets grabbed. #[test] fn two_ids_that_disagree_match_nothing() { assert_eq!( match_movie( &wanted(), &ids(Some(693_134), Some("tt1160419")), &arr_parse::parse("Dune.Part.Two.2024.2160p.WEB-DL"), ), None ); } /// One id the library does not carry does not veto the other: a title /// TMDB knows no `IMDb` id for is matched by its TMDB id as before. #[test] fn an_id_the_library_lacks_does_not_block_the_other() { assert_eq!( match_movie( &wanted(), &ids(Some(194), Some("tt0211915")), &arr_parse::parse("Amelie.2001.1080p.BluRay"), ), Some(MovieMatch { movie: MovieId(3), kind: MatchKind::TmdbId, }) ); } fn wanted_episode() -> WantedEpisode { WantedEpisode { id: EpisodeId(7), tmdb_id: Some(934_644), imdb_id: Some("tt11301866".to_owned()), title: "Fallout".to_owned(), season: 1, episode: 3, } } fn episode_ids(tmdb_id: Option, imdb_id: Option<&str>) -> ReleaseIds { ids(tmdb_id, imdb_id) } /// `(release name, expected shape)` for releases that satisfy the /// wanted `Fallout` S01E03, matched on title alone. #[test] fn real_single_episode_releases_match_their_episode() { let cases = [ ( "Fallout.2024.S01E03.1080p.WEB-DL.DDP5.1.H.264-GROUP", MatchShape::SingleEpisode, ), ( "Fallout.S01E03.2160p.WEB-DL.DV.HDR10Plus.HEVC-GROUP", MatchShape::SingleEpisode, ), ( "Fallout.S01E03.720p.AMZN.WEBRip.DDP5.1.x264-GROUP", MatchShape::SingleEpisode, ), ]; for (name, shape) in cases { assert_eq!( match_episode( &wanted_episode(), &ReleaseIds::default(), &arr_parse::parse(name), ), Some(EpisodeMatch { episode: EpisodeId(7), kind: MatchKind::TitleAndYear, shape, }), "{name}" ); } } /// The same series, offered as a pack for exactly its season. #[test] fn a_pack_for_this_season_matches_every_episode_in_it() { let cases = [ ( "Fallout.S01.2160p.WEB-DL.DDP5.1.Atmos.H.265-GROUP", MatchShape::SeasonPack, ), ( "Fallout.Season.1.1080p.BluRay.x265-GROUP", MatchShape::SeasonPack, ), ( "Fallout.S01.1080p.BluRay.x264-GROUP", MatchShape::SeasonPack, ), ( "Fallout.S01-S01.1080p.BluRay.x264-GROUP", MatchShape::SeasonPack, ), ]; for (name, shape) in cases { assert_eq!( match_episode( &wanted_episode(), &ReleaseIds::default(), &arr_parse::parse(name), ), Some(EpisodeMatch { episode: EpisodeId(7), kind: MatchKind::TitleAndYear, shape, }), "{name}" ); } } /// `COMPLETE` before the season tag used to stay in the title and /// break the exact-title comparison (#135). #[test] fn a_pack_marker_before_the_tag_still_matches() { let wanted = WantedEpisode { id: EpisodeId(10), tmdb_id: None, imdb_id: None, title: "Bluey".to_owned(), season: 1, episode: 3, }; assert_eq!( match_episode( &wanted, &ReleaseIds::default(), &arr_parse::parse("Bluey.COMPLETE.S01.1080p.WEB-DL-GROUP"), ), Some(EpisodeMatch { episode: EpisodeId(10), kind: MatchKind::TitleAndYear, shape: MatchShape::SeasonPack, }) ); } /// Punctuation, case and accents in the series title do not block the /// match. #[test] fn mangled_series_titles_still_match() { let wanted = WantedEpisode { id: EpisodeId(8), tmdb_id: None, imdb_id: None, title: "Ms. Marvel".to_owned(), season: 1, episode: 3, }; assert_eq!( match_episode( &wanted, &ReleaseIds::default(), &arr_parse::parse("Ms.Marvel.S01E03.1080p.DSNY.WEB-DL.DDP5.1.Atmos.H.264-GROUP"), ) .map(|matched| matched.shape), Some(MatchShape::SingleEpisode) ); } /// Two series that share a word are different series. Both pairs are /// real shows. #[test] fn another_series_sharing_a_word_is_not_a_match() { let lone_star = WantedEpisode { id: EpisodeId(9), tmdb_id: None, imdb_id: None, title: "9-1-1: Lone Star".to_owned(), season: 4, episode: 1, }; assert_eq!( match_episode( &lone_star, &ReleaseIds::default(), &arr_parse::parse("9-1-1.S07E01.1080p.AMZN.WEB-DL.DDP5.1.H.264-GROUP"), ), None ); let fallout = wanted_episode(); assert_eq!( match_episode( &fallout, &ReleaseIds::default(), &arr_parse::parse("The.Fallout.2021.S01E03.1080p.WEB-DL"), ), None ); } /// A tracker-supplied id identifies the series whatever the name says. #[test] fn a_supplied_id_matches_whatever_the_name_says_tv() { for (tmdb_id, imdb_id) in [(Some(934_644), None), (None, Some("tt11301866"))] { assert_eq!( match_episode( &wanted_episode(), &episode_ids(tmdb_id, imdb_id), &arr_parse::parse("Totally.Unrelated.Name.S01.1080p.WEB-DL-GROUP"), ), Some(EpisodeMatch { episode: EpisodeId(7), kind: if tmdb_id.is_some() { MatchKind::TmdbId } else { MatchKind::ImdbId }, shape: MatchShape::SeasonPack, }), "{tmdb_id:?} {imdb_id:?}" ); } } /// Torznab definitions spell the same id several ways; all of them are /// the one series. #[test] fn an_imdb_id_matches_however_the_tracker_spells_it_tv() { for spelling in ["tt11301866", "11301866", "tt011301866"] { assert_eq!( match_episode( &wanted_episode(), &episode_ids(None, Some(spelling)), &arr_parse::parse("Unrelated.Name.S01E03.1080p.WEB-DL"), ) .map(|matched| matched.kind), Some(MatchKind::ImdbId), "{spelling}" ); } } /// Same rule as films: the tracker said which series this is and it is /// not ours, so the title does not get a vote. #[test] fn a_supplied_id_that_is_not_wanted_ends_the_comparison_tv() { assert_eq!( match_episode( &wanted_episode(), &episode_ids(Some(1), None), &arr_parse::parse("Fallout.S01E03.1080p.WEB-DL"), ), None ); assert_eq!( match_episode( &wanted_episode(), &episode_ids(None, Some("tt0000001")), &arr_parse::parse("Fallout.S01E03.1080p.WEB-DL"), ), None ); } /// A placeholder or a non-id is no id at all, so the title lane still /// runs. #[test] fn a_junk_imdb_id_falls_through_to_the_title_tv() { for junk in ["", "tt", "tt0000000", "n/a"] { assert_eq!( match_episode( &wanted_episode(), &episode_ids(None, Some(junk)), &arr_parse::parse("Fallout.S01E03.1080p.WEB-DL"), ) .map(|matched| matched.shape), Some(MatchShape::SingleEpisode), "{junk}" ); } } /// Everything that is not this exact episode or this exact season's /// pack satisfies nothing, whoever issued it. #[test] fn every_other_shape_satisfies_nothing() { let refusals = [ // Wrong episode, wrong season. "Fallout.S01E04.1080p.WEB-DL-GROUP", "Fallout.S02E03.1080p.WEB-DL-GROUP", // Multi-episode files fight over one grabs row; manual only. "Fallout.S01E02E03.1080p.WEB-DL-GROUP", "Fallout.S01E02-E04.1080p.WEB-DL-GROUP", // Another season's pack, and a multi-season pack. "Fallout.S02.2160p.WEB-DL-GROUP", "Fallout.S01-S03.1080p.BluRay-GROUP", // A daily-show air date is not a numbered episode. "Last.Week.Tonight.With.John.Oliver.2024.05.13.1080p.WEB-DL", // No TV tag at all: a film, not an episode of anything. "A.Complete.Unknown.2024.2160p.WEB-DL-GROUP", ]; for name in refusals { assert_eq!( match_episode( &wanted_episode(), &ReleaseIds::default(), &arr_parse::parse(name), ), None, "{name}" ); } } /// A degenerate range means one season's pack, not a multi-season one. #[test] fn a_degenerate_season_range_is_this_seasons_pack() { use super::{is_single_episode, is_this_seasons_pack}; use arr_parse::EpisodeClaim::{Daily, Episodes, Season, Seasons}; assert!(is_this_seasons_pack(&Seasons { first: 1, last: 1 }, 1)); assert!(!is_this_seasons_pack(&Seasons { first: 1, last: 3 }, 1)); assert!(!is_this_seasons_pack( &Episodes { season: 1, episodes: vec![3] }, 1 )); assert!(!is_this_seasons_pack(&Season { season: 2 }, 1)); assert!(!is_this_seasons_pack( &Daily { year: 2024, month: 5, day: 13 }, 1 )); // A single episode of another season is still not this one. assert!(!is_single_episode( &Episodes { season: 2, episodes: vec![3] }, 1, 3 )); } /// A daily show's own episode, dated but unnumbered, satisfies nothing: /// there is no numbered wanted episode it can be filed against. #[test] fn a_daily_claim_never_satisfies_a_numbered_wanted_episode() { let wanted = WantedEpisode { id: EpisodeId(10), tmdb_id: Some(46_298), imdb_id: None, title: "Last Week Tonight with John Oliver".to_owned(), season: 11, episode: 17, }; assert_eq!( match_episode( &wanted, &ReleaseIds::default(), &arr_parse::parse("Last.Week.Tonight.With.John.Oliver.2024.05.13.1080p.WEB-DL"), ), None ); } }