public void Setup() { _series = Builder <Series> .CreateNew() .Build(); _episode = Builder <Episode> .CreateNew() .With(e => e.SeriesId = _series.SeriesId) .With(e => e.Series = _series) .Build(); _episodeParseResult = Builder <EpisodeParseResult> .CreateNew() .With(p => p.SeasonNumber = 1) .With(p => p.EpisodeNumbers = new List <int> { _episode.EpisodeNumber }) .With(p => p.Episodes = new List <Episode> { _episode }) .With(p => p.Series = _series) .Build(); _searchHistoryItem = new SearchHistoryItem(); }
public void should_not_repeat_the_same_episode_title() { var series = Builder <Series> .CreateNew() .With(c => c.Title = "My Series Name") .Build(); var fakeEpisodes = Builder <Episode> .CreateListOfSize(2) .All() .With(e => e.SeasonNumber = 5) .TheFirst(1) .With(e => e.Title = "My Episode Title (1)") .TheLast(1) .With(e => e.Title = "My Episode Title (2)") .Build(); var parsResult = new EpisodeParseResult { AirDate = DateTime.Now, EpisodeNumbers = new List <int> { 10, 11 }, Quality = new QualityModel(QualityTypes.HDTV720p, false), SeasonNumber = 35, Series = series, Episodes = fakeEpisodes }; Mocker.Resolve <DownloadProvider>().GetDownloadTitle(parsResult).Should().Be("My Series Name - 5x01-5x02 - My Episode Title [HDTV-720p]"); }
private void WithEnglishRelease() { parseResult = Builder <EpisodeParseResult> .CreateNew() .With(p => p.Language = LanguageType.English) .Build(); }
public void create_proper_sab_titles(int seasons, int[] episodes, string title, QualityTypes quality, bool proper, string expected) { var series = Builder <Series> .CreateNew() .With(c => c.Title = "My Series Name") .Build(); var fakeEpisodes = new List <Episode>(); foreach (var episode in episodes) { fakeEpisodes.Add(Builder <Episode> .CreateNew() .With(e => e.EpisodeNumber = episode) .With(e => e.Title = title) .Build()); } var parsResult = new EpisodeParseResult() { AirDate = DateTime.Now, EpisodeNumbers = episodes.ToList(), Quality = new QualityModel(quality, proper), SeasonNumber = seasons, Series = series, EpisodeTitle = title, Episodes = fakeEpisodes }; Mocker.Resolve <DownloadProvider>().GetDownloadTitle(parsResult).Should().Be(expected); }
public void GetEpisodeParseResult_should_return_single_title_for_multiple_episodes() { Db.Insert(fakeSeries); Db.Insert(fakeEpisode); Db.Insert(fakeEpisode2); var parseResult = new EpisodeParseResult { Series = fakeSeries, SeasonNumber = fakeEpisode.SeasonNumber, EpisodeNumbers = new List <int> { fakeEpisode.EpisodeNumber, fakeEpisode2.EpisodeNumber } }; var ep = episodeProvider.GetEpisodesByParseResult(parseResult); ep.Should().HaveCount(2); Db.Fetch <Episode>().Should().HaveCount(2); VerifyEpisode(ep[0], fakeEpisode); VerifyEpisode(ep[1], fakeEpisode2); parseResult.EpisodeTitle.Should().Be("Episode"); }
public virtual bool IsSatisfiedBy(EpisodeParseResult subject) { var series = _seriesProvider.FindSeries(subject.CleanTitle); if (series == null) { logger.Trace("{0} is not mapped to any series in DB. skipping", subject.CleanTitle); return(false); } subject.Series = series; if (!series.Monitored) { logger.Debug("{0} is present in the DB but not tracked. skipping.", subject.CleanTitle); return(false); } var episodes = _episodeProvider.GetEpisodesByParseResult(subject); subject.Episodes = episodes; //return monitored if any of the episodes are monitored if (episodes.Any(episode => !episode.Ignored)) { return(true); } logger.Debug("All episodes are ignored. skipping."); return(false); }
public virtual bool IsInQueue(EpisodeParseResult newParseResult) { try { var queue = GetQueue().Where(c => c.ParseResult != null); var matchigTitle = queue.Where(q => String.Equals(q.ParseResult.CleanTitle, newParseResult.Series.CleanTitle, StringComparison.InvariantCultureIgnoreCase)); var matchingTitleWithQuality = matchigTitle.Where(q => q.ParseResult.Quality >= newParseResult.Quality); if (newParseResult.Series.IsDaily) { return(matchingTitleWithQuality.Any(q => q.ParseResult.AirDate.Value.Date == newParseResult.AirDate.Value.Date)); } var matchingSeason = matchingTitleWithQuality.Where(q => q.ParseResult.SeasonNumber == newParseResult.SeasonNumber); if (newParseResult.FullSeason) { return(matchingSeason.Any()); } return(matchingSeason.Any(q => q.ParseResult.EpisodeNumbers != null && q.ParseResult.EpisodeNumbers.Any(e => newParseResult.EpisodeNumbers.Contains(e)))); } catch (Exception ex) { logger.WarnException("Unable to connect to Nzbget to check queue.", ex); return(false); } }
private void WithGermanRelease() { parseResult = Builder <EpisodeParseResult> .CreateNew() .With(p => p.Language = LanguageType.German) .Build(); }
public void Setup() { Mocker.Resolve <QualityUpgradeSpecification>(); _upgradeDisk = Mocker.Resolve <UpgradeDiskSpecification>(); firstFile = new EpisodeFile { Quality = QualityTypes.Bluray1080p, Proper = true, DateAdded = DateTime.Now }; secondFile = new EpisodeFile { Quality = QualityTypes.Bluray1080p, Proper = true, DateAdded = DateTime.Now }; var singleEpisodeList = new List <Episode> { new Episode { EpisodeFile = firstFile }, new Episode { EpisodeFile = null } }; var doubleEpisodeList = new List <Episode> { new Episode { EpisodeFile = firstFile }, new Episode { EpisodeFile = secondFile }, new Episode { EpisodeFile = null } }; var fakeSeries = Builder <Series> .CreateNew() .With(c => c.QualityProfile = new QualityProfile { Cutoff = QualityTypes.Bluray1080p }) .Build(); parseResultMulti = new EpisodeParseResult { Series = fakeSeries, Quality = new QualityModel(QualityTypes.DVD, true), EpisodeNumbers = new List <int> { 3, 4 }, SeasonNumber = 12, Episodes = doubleEpisodeList }; parseResultSingle = new EpisodeParseResult { Series = fakeSeries, Quality = new QualityModel(QualityTypes.DVD, true), EpisodeNumbers = new List <int> { 3 }, SeasonNumber = 12, Episodes = singleEpisodeList }; }
protected override EpisodeParseResult CustomParser(SyndicationItem item, EpisodeParseResult currentResult) { if (currentResult != null) { currentResult.Size = 0; } return(currentResult); }
public void Setup() { retentionSpecification = Mocker.Resolve <RetentionSpecification>(); parseResult = new EpisodeParseResult { Age = 100 }; }
public void should_return_true_if_RAWHD() { var parseResult = new EpisodeParseResult { Quality = new QualityModel(QualityTypes.RAWHD, false) }; Mocker.Resolve <AcceptableSizeSpecification>().IsSatisfiedBy(parseResult).Should().BeTrue(); }
protected override EpisodeParseResult CustomParser(SyndicationItem item, EpisodeParseResult currentResult) { if (currentResult == null) { currentResult = new EpisodeParseResult(); } currentResult.Language = LanguageType.Finnish; return(currentResult); }
public void Setup() { Mocker.Resolve <QualityUpgradeSpecification>(); _upgradeHistory = Mocker.Resolve <UpgradeHistorySpecification>(); var singleEpisodeList = new List <Episode> { new Episode { SeasonNumber = 12, EpisodeNumber = 3 } }; var doubleEpisodeList = new List <Episode> { new Episode { SeasonNumber = 12, EpisodeNumber = 3 }, new Episode { SeasonNumber = 12, EpisodeNumber = 4 }, new Episode { SeasonNumber = 12, EpisodeNumber = 5 } }; fakeSeries = Builder <Series> .CreateNew() .With(c => c.QualityProfile = new QualityProfile { Cutoff = QualityTypes.Bluray1080p }) .Build(); parseResultMulti = new EpisodeParseResult { Series = fakeSeries, Quality = new QualityModel(QualityTypes.DVD, true), EpisodeNumbers = new List <int> { 3, 4 }, SeasonNumber = 12, Episodes = doubleEpisodeList }; parseResultSingle = new EpisodeParseResult { Series = fakeSeries, Quality = new QualityModel(QualityTypes.DVD, true), EpisodeNumbers = new List <int> { 3 }, SeasonNumber = 12, Episodes = singleEpisodeList }; firstQuality = new QualityModel(QualityTypes.Bluray1080p, true); secondQuality = new QualityModel(QualityTypes.Bluray1080p, true); Mocker.GetMock <HistoryProvider>().Setup(c => c.GetBestQualityInHistory(fakeSeries.SeriesId, 12, 3)).Returns(firstQuality); Mocker.GetMock <HistoryProvider>().Setup(c => c.GetBestQualityInHistory(fakeSeries.SeriesId, 12, 4)).Returns(secondQuality); Mocker.GetMock <HistoryProvider>().Setup(c => c.GetBestQualityInHistory(fakeSeries.SeriesId, 12, 5)).Returns <QualityModel>(null); }
protected override EpisodeParseResult CustomParser(SyndicationItem item, EpisodeParseResult currentResult) { if (currentResult != null) { var sizeString = Regex.Match(item.Summary.Text, @"\d+\.\d{1,2} \w{3}", RegexOptions.IgnoreCase).Value; currentResult.Size = Parser.GetReportSize(sizeString); } return(currentResult); }
public virtual bool IsSatisfiedBy(EpisodeParseResult subject) { logger.Trace("Checking if report meets language requirements. {0}", subject.Language); if (subject.Language != LanguageType.English) { logger.Trace("Report Language: {0} rejected because it is not english", subject.Language); return(false); } return(true); }
public virtual bool IsSatisfiedBy(EpisodeParseResult subject) { logger.Trace("Checking if report meets quality requirements. {0}", subject.Quality); if (!subject.Series.QualityProfile.Allowed.Contains(subject.Quality.Quality)) { logger.Trace("Quality {0} rejected by Series' quality profile", subject.Quality); return(false); } return(true); }
public virtual bool IsSatisfiedBy(EpisodeParseResult subject) { logger.Trace("Checking if report meets retention requirements. {0}", subject.Age); if (_configProvider.Retention > 0 && subject.Age > _configProvider.Retention) { logger.Trace("Report age: {0} rejected by user's retention limit", subject.Age); return(false); } return(true); }
public void tostring_daily_show_proper() { var parseResult = new EpisodeParseResult(); parseResult.SeriesTitle = "My Series"; parseResult.SeasonNumber = 12; parseResult.FullSeason = true; parseResult.AirDate = new DateTime(2010, 12, 30); parseResult.Quality = new QualityModel(QualityTypes.HDTV720p, true); parseResult.ToString().Should().Be("My Series - 2010-12-30 HDTV-720p [proper]"); }
public void tostring_full_season() { var parseResult = new EpisodeParseResult(); parseResult.SeriesTitle = "My Series"; parseResult.SeasonNumber = 12; parseResult.FullSeason = true; parseResult.AirDate = null; parseResult.Quality = new QualityModel(QualityTypes.HDTV720p, false); parseResult.ToString().Should().Be("My Series - Season 12 HDTV-720p"); }
protected override EpisodeParseResult CustomParser(SyndicationItem item, EpisodeParseResult currentResult) { if (currentResult != null) { if (item.Links.Count > 1) { currentResult.Size = item.Links[1].Length; } currentResult.Indexer = GetName(item); } return(currentResult); }
public virtual bool IsSatisfiedBy(EpisodeParseResult subject) { logger.Trace("Beginning size check for: {0}", subject); if (subject.Quality.Quality == QualityTypes.RAWHD) { logger.Trace("Raw-HD release found, skipping size check."); return(true); } var qualityType = _qualityTypeProvider.Get((int)subject.Quality.Quality); if (qualityType.MaxSize == 0) { logger.Trace("Max size is 0 (unlimited) - skipping check."); return(true); } var maxSize = qualityType.MaxSize.Megabytes(); var series = subject.Series; //Multiply maxSize by Series.Runtime maxSize = maxSize * series.Runtime; //Multiply maxSize by the number of episodes parsed (if EpisodeNumbers is null it will be treated as a single episode) //TODO: is this check really necessary? shouldn't we blowup? if (subject.EpisodeNumbers != null) { maxSize = maxSize * subject.EpisodeNumbers.Count; } //Check if there was only one episode parsed //and it is the first or last episode of the season if (subject.EpisodeNumbers != null && subject.EpisodeNumbers.Count == 1 && _episodeProvider.IsFirstOrLastEpisodeOfSeason(series.SeriesId, subject.SeasonNumber, subject.EpisodeNumbers[0])) { maxSize = maxSize * 2; } //If the parsed size is greater than maxSize we don't want it if (subject.Size > maxSize) { logger.Trace("Item: {0}, Size: {1} is greater than maximum allowed size ({2}), rejecting.", subject, subject.Size, maxSize); return(false); } logger.Trace("Item: {0}, meets size contraints.", subject); return(true); }
public void Setup() { parseResult = new EpisodeParseResult { SeriesTitle = "Title", Language = LanguageType.English, Quality = new QualityModel(QualityTypes.SDTV, true), EpisodeNumbers = new List <int> { 3 }, SeasonNumber = 12, AirDate = DateTime.Now.AddDays(-12).Date, ReleaseGroup = "2HD" }; }
public void GetEpisodeParseResult_should_return_nothing_when_series_is_not_daily_but_parsed_daily() { Db.Insert(fakeSeries); var parseResult = new EpisodeParseResult { Series = fakeSeries, AirDate = DateTime.Today }; var ep = episodeProvider.GetEpisodesByParseResult(parseResult); ep.Should().BeEmpty(); ExceptionVerification.ExpectedWarns(1); }
public void Setup() { monitoredEpisodeSpecification = Mocker.Resolve <MonitoredEpisodeSpecification>(); fakeSeries = Builder <Series> .CreateNew() .With(c => c.Monitored = true) .Build(); parseResultMulti = new EpisodeParseResult { SeriesTitle = "Title", Series = fakeSeries, EpisodeNumbers = new List <int> { 3, 4 }, SeasonNumber = 12, }; parseResultSingle = new EpisodeParseResult { SeriesTitle = "Title", Series = fakeSeries, EpisodeNumbers = new List <int> { 3 }, SeasonNumber = 12, }; firstEpisode = new Episode { Ignored = false }; secondEpisode = new Episode { Ignored = false }; var singleEpisodeList = new List <Episode> { firstEpisode }; var doubleEpisodeList = new List <Episode> { firstEpisode, secondEpisode }; Mocker.GetMock <EpisodeProvider>().Setup(c => c.GetEpisodesByParseResult(parseResultSingle)).Returns(singleEpisodeList); Mocker.GetMock <EpisodeProvider>().Setup(c => c.GetEpisodesByParseResult(parseResultMulti)).Returns(doubleEpisodeList); Mocker.GetMock <SeriesProvider>().Setup(c => c.FindSeries(parseResultMulti.CleanTitle)).Returns(fakeSeries); Mocker.GetMock <SeriesProvider>().Setup(c => c.FindSeries(parseResultSingle.CleanTitle)).Returns(fakeSeries); }
public void tostring_single_season_episode() { var parseResult = new EpisodeParseResult(); parseResult.SeriesTitle = "My Series"; parseResult.SeasonNumber = 12; parseResult.EpisodeNumbers = new List <int> { 3 }; parseResult.FullSeason = false; parseResult.AirDate = null; parseResult.Quality = new QualityModel(QualityTypes.HDTV720p, false); parseResult.ToString().Should().Be("My Series - S12E03 HDTV-720p"); }
public void tostring_multi_season_episode_proper() { var parseResult = new EpisodeParseResult(); parseResult.SeriesTitle = "My Series"; parseResult.SeasonNumber = 12; parseResult.EpisodeNumbers = new List <int> { 3, 4, 5 }; parseResult.FullSeason = false; parseResult.AirDate = null; parseResult.Quality = new QualityModel(QualityTypes.HDTV720p, true); parseResult.ToString().Should().Be("My Series - S12E03-04-05 HDTV-720p [proper]"); }
public void single_none_existing_episode_should_return_nothing_and_add_nothing() { var parseResult = new EpisodeParseResult { Series = fakeSeries, SeasonNumber = fakeEpisode.SeasonNumber, EpisodeNumbers = new List <int> { 10 } }; var episode = episodeProvider.GetEpisodesByParseResult(parseResult); episode.Should().BeEmpty(); Db.Fetch <Episode>().Should().HaveCount(0); }
public void none_existing_multi_episode_should_not_return_or_add_anything() { var parseResult = new EpisodeParseResult { Series = fakeSeries, SeasonNumber = fakeEpisode.SeasonNumber, EpisodeNumbers = new List <int> { fakeEpisode.EpisodeNumber, fakeEpisode2.EpisodeNumber } }; var ep = episodeProvider.GetEpisodesByParseResult(parseResult); ep.Should().BeEmpty(); Db.Fetch <Episode>().Should().BeEmpty(); }
public virtual bool IsSatisfiedBy(EpisodeParseResult subject) { foreach (var episode in subject.Episodes) { var bestQualityInHistory = _historyProvider.GetBestQualityInHistory(subject.Series.SeriesId, episode.SeasonNumber, episode.EpisodeNumber); if (bestQualityInHistory != null) { logger.Trace("Comparing history quality with report. History is {0}", bestQualityInHistory); if (!_qualityUpgradeSpecification.IsSatisfiedBy(bestQualityInHistory, subject.Quality, subject.Series.QualityProfile.Cutoff)) { return(false); } } } return(true); }