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);
}