tedkulp/Readarr
1
0
Fork 0
mirror of https://github.com/Readarr/Readarr.git synced 2026-04-23 22:25:09 -04:00
Code Issues Projects Releases Wiki Activity

Implement Release Parsing, Decision Engine, and Downloading (#35)

Browse Source 
* Implement Parsing, Decision Engine, and Downloading
This commit is contained in:
Qstick
2017-08-13 22:58:42 -04:00
committed by GitHub
parent 5556989324
commit 1e4d9480e9
191 changed files with 2604 additions and 2755 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/NzbDrone.Core.Test/DecisionEngineTests/AcceptableSizeSpecificationFixture.cs
+70 -123
View File
@@ -8,7 +8,7 @@ using NzbDrone.Core.DecisionEngine.Specifications;
using NzbDrone.Core.Parser.Model;
using NzbDrone.Core.Qualities;
using NzbDrone.Core.Test.Framework;
using NzbDrone.Core.Tv;
using NzbDrone.Core.Music;
namespace NzbDrone.Core.Test.DecisionEngineTests
{
@@ -16,40 +16,40 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
public class AcceptableSizeSpecificationFixture : CoreTest<AcceptableSizeSpecification>
{
private RemoteEpisode parseResultMultiSet;
private RemoteEpisode parseResultMulti;
private RemoteEpisode parseResultSingle;
private Series series;
private RemoteAlbum parseResultMultiSet;
private RemoteAlbum parseResultMulti;
private RemoteAlbum parseResultSingle;
private Artist artist;
private QualityDefinition qualityType;
[SetUp]
public void Setup()
{
series = Builder<Series>.CreateNew()
artist = Builder<Artist>.CreateNew()
.Build();
parseResultMultiSet = new RemoteEpisode
{
Series = series,
parseResultMultiSet = new RemoteAlbum
{
Artist = artist,
Release = new ReleaseInfo(),
ParsedEpisodeInfo = new ParsedEpisodeInfo { Quality = new QualityModel(Quality.MP3_192, new Revision(version: 2)) },
Episodes = new List<Episode> { new Episode(), new Episode(), new Episode(), new Episode(), new Episode(), new Episode() }
ParsedAlbumInfo = new ParsedAlbumInfo { Quality = new QualityModel(Quality.MP3_192, new Revision(version: 2)) },
Albums = new List<Album> { new Album(), new Album(), new Album(), new Album(), new Album(), new Album() }
};
parseResultMulti = new RemoteEpisode
{
Series = series,
parseResultMulti = new RemoteAlbum
{
Artist = artist,
Release = new ReleaseInfo(),
ParsedEpisodeInfo = new ParsedEpisodeInfo { Quality = new QualityModel(Quality.MP3_192, new Revision(version: 2)) },
Episodes = new List<Episode> { new Episode(), new Episode() }
ParsedAlbumInfo = new ParsedAlbumInfo { Quality = new QualityModel(Quality.MP3_192, new Revision(version: 2)) },
Albums = new List<Album> { new Album(), new Album() }
};
parseResultSingle = new RemoteEpisode
{
Series = series,
parseResultSingle = new RemoteAlbum
{
Artist = artist,
Release = new ReleaseInfo(),
ParsedEpisodeInfo = new ParsedEpisodeInfo { Quality = new QualityModel(Quality.MP3_192, new Revision(version: 2)) },
Episodes = new List<Episode> { new Episode() { Id = 2 } }
ParsedAlbumInfo = new ParsedAlbumInfo { Quality = new QualityModel(Quality.MP3_192, new Revision(version: 2)) },
Albums = new List<Album> { new Album { Id = 2 } }
};
@@ -59,83 +59,68 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
qualityType = Builder<QualityDefinition>.CreateNew()
.With(q => q.MinSize = 2)
.With(q => q.MaxSize = 10)
.With(q => q.MaxSize = 6)
.With(q => q.Quality = Quality.MP3_192)
.Build();
Mocker.GetMock<IQualityDefinitionService>().Setup(s => s.Get(Quality.MP3_192)).Returns(qualityType);
Mocker.GetMock<IEpisodeService>().Setup(
s => s.GetEpisodesBySeason(It.IsAny<int>(), It.IsAny<int>()))
.Returns(new List<Episode>() {
new Episode(), new Episode(), new Episode(), new Episode(), new Episode(),
new Episode(), new Episode(), new Episode(), new Episode() { Id = 2 }, new Episode() });
Mocker.GetMock<IAlbumService>().Setup(
s => s.GetAlbumsByArtist(It.IsAny<int>()))
.Returns(new List<Album>() {
new Album(), new Album(), new Album(), new Album(), new Album(),
new Album(), new Album(), new Album(), new Album { Id = 2 }, new Album() });
}
private void GivenLastEpisode()
private void GivenLastAlbum()
{
Mocker.GetMock<IEpisodeService>().Setup(
s => s.GetEpisodesBySeason(It.IsAny<int>(), It.IsAny<int>()))
.Returns(new List<Episode>() {
new Episode(), new Episode(), new Episode(), new Episode(), new Episode(),
new Episode(), new Episode(), new Episode(), new Episode(), new Episode() { Id = 2 } });
Mocker.GetMock<IAlbumService>().Setup(
s => s.GetAlbumsByArtist(It.IsAny<int>()))
.Returns(new List<Album> {
new Album(), new Album(), new Album(), new Album(), new Album(),
new Album(), new Album(), new Album(), new Album(), new Album { Id = 2 } });
}
[TestCase(30, 50, false)]
[TestCase(30, 250, true)]
[TestCase(30, 500, false)]
[TestCase(60, 100, false)]
[TestCase(60, 500, true)]
[TestCase(60, 1000, false)]
public void single_episode(int runtime, int sizeInMegaBytes, bool expectedResult)
{
series.Runtime = runtime;
parseResultSingle.Series = series;
[TestCase(1800000, 50, false)]
[TestCase(1800000, 150, true)]
[TestCase(1800000, 300, false)]
[TestCase(3600000, 100, false)]
[TestCase(3600000, 300, true)]
[TestCase(3600000, 600, false)]
public void single_album(int runtime, int sizeInMegaBytes, bool expectedResult)
{
parseResultSingle.Albums.Select(c => { c.Duration = runtime; return c; }).ToList();
parseResultSingle.Artist = artist;
parseResultSingle.Release.Size = sizeInMegaBytes.Megabytes();
Subject.IsSatisfiedBy(parseResultSingle, null).Accepted.Should().Be(expectedResult);
}
[TestCase(30, 500, true)]
[TestCase(30, 1000, false)]
[TestCase(60, 1000, true)]
[TestCase(60, 2000, false)]
public void single_episode_first_or_last(int runtime, int sizeInMegaBytes, bool expectedResult)
[TestCase(1800000, 50 * 2, false)]
[TestCase(1800000, 150 * 2, true)]
[TestCase(1800000, 300 * 2, false)]
[TestCase(3600000, 100 * 2, false)]
[TestCase(3600000, 300 * 2, true)]
[TestCase(3600000, 600 * 2, false)]
public void multi_album(int runtime, int sizeInMegaBytes, bool expectedResult)
{
GivenLastEpisode();
series.Runtime = runtime;
parseResultSingle.Series = series;
parseResultSingle.Release.Size = sizeInMegaBytes.Megabytes();
Subject.IsSatisfiedBy(parseResultSingle, null).Accepted.Should().Be(expectedResult);
}
[TestCase(30, 50 * 2, false)]
[TestCase(30, 250 * 2, true)]
[TestCase(30, 500 * 2, false)]
[TestCase(60, 100 * 2, false)]
[TestCase(60, 500 * 2, true)]
[TestCase(60, 1000 * 2, false)]
public void multi_episode(int runtime, int sizeInMegaBytes, bool expectedResult)
{
series.Runtime = runtime;
parseResultMulti.Series = series;
parseResultMulti.Albums.Select(c => { c.Duration = runtime; return c; }).ToList();
parseResultMulti.Artist = artist;
parseResultMulti.Release.Size = sizeInMegaBytes.Megabytes();
Subject.IsSatisfiedBy(parseResultMulti, null).Accepted.Should().Be(expectedResult);
}
[TestCase(30, 50 * 6, false)]
[TestCase(30, 250 * 6, true)]
[TestCase(30, 500 * 6, false)]
[TestCase(60, 100 * 6, false)]
[TestCase(60, 500 * 6, true)]
[TestCase(60, 1000 * 6, false)]
public void multiset_episode(int runtime, int sizeInMegaBytes, bool expectedResult)
[TestCase(1800000, 50 * 6, false)]
[TestCase(1800000, 150 * 6, true)]
[TestCase(1800000, 300 * 6, false)]
[TestCase(3600000, 100 * 6, false)]
[TestCase(3600000, 300 * 6, true)]
[TestCase(3600000, 600 * 6, false)]
public void multiset_album(int runtime, int sizeInMegaBytes, bool expectedResult)
{
series.Runtime = runtime;
parseResultMultiSet.Series = series;
parseResultMultiSet.Albums.Select(c => { c.Duration = runtime; return c; }).ToList();
parseResultMultiSet.Artist = artist;
parseResultMultiSet.Release.Size = sizeInMegaBytes.Megabytes();
Subject.IsSatisfiedBy(parseResultMultiSet, null).Accepted.Should().Be(expectedResult);
@@ -144,10 +129,9 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
[Test]
public void should_return_true_if_size_is_zero()
{
GivenLastEpisode();
series.Runtime = 30;
parseResultSingle.Series = series;
GivenLastAlbum();
parseResultSingle.Albums.Select(c => { c.Duration = 1800000; return c; }).ToList();
parseResultSingle.Artist = artist;
parseResultSingle.Release.Size = 0;
qualityType.MinSize = 10;
qualityType.MaxSize = 20;
@@ -158,10 +142,9 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
[Test]
public void should_return_true_if_unlimited_30_minute()
{
GivenLastEpisode();
series.Runtime = 30;
parseResultSingle.Series = series;
GivenLastAlbum();
parseResultSingle.Albums.Select(c => { c.Duration = 1800000; return c; }).ToList();
parseResultSingle.Artist = artist;
parseResultSingle.Release.Size = 18457280000;
qualityType.MaxSize = null;
@@ -171,50 +154,14 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
[Test]
public void should_return_true_if_unlimited_60_minute()
{
GivenLastEpisode();
series.Runtime = 60;
parseResultSingle.Series = series;
GivenLastAlbum();
parseResultSingle.Albums.Select(c => { c.Duration = 3600000; return c; }).ToList();
parseResultSingle.Artist = artist;
parseResultSingle.Release.Size = 36857280000;
qualityType.MaxSize = null;
Subject.IsSatisfiedBy(parseResultSingle, null).Accepted.Should().BeTrue();
}
[Test]
public void should_treat_daily_series_as_single_episode()
{
GivenLastEpisode();
series.Runtime = 60;
parseResultSingle.Series = series;
parseResultSingle.Series.SeriesType = SeriesTypes.Daily;
parseResultSingle.Release.Size = 300.Megabytes();
qualityType.MaxSize = 10;
Subject.IsSatisfiedBy(parseResultSingle, null).Accepted.Should().BeTrue();
}
[Test]
public void should_return_true_if_RAWHD()
{
parseResultSingle.ParsedEpisodeInfo.Quality = new QualityModel(Quality.FLAC);
series.Runtime = 45;
parseResultSingle.Series = series;
parseResultSingle.Series.SeriesType = SeriesTypes.Daily;
parseResultSingle.Release.Size = 8000.Megabytes();
Subject.IsSatisfiedBy(parseResultSingle, null).Accepted.Should().BeTrue();
}
[Test]
public void should_return_true_for_special()
{
parseResultSingle.ParsedEpisodeInfo.Special = true;
Subject.IsSatisfiedBy(parseResultSingle, null).Accepted.Should().BeTrue();
}
}
}