Processing of Daily Episode searching now supported.

NzbDrone.Core.Test/NzbDrone.Core.Test.csproj

@@ -99,6 +99,7 @@
     <Compile Include="JobTests\RecentBacklogSearchJobTest.cs" />
     <Compile Include="ProviderTests\ReferenceDataProviderTest.cs" />
     <Compile Include="ProviderTests\NotificationProviderTests\NotificationProviderFixture.cs" />
+    <Compile Include="ProviderTests\SearchProviderTests\ProcessDailySearchResultsFixture.cs" />
     <Compile Include="ProviderTests\SearchProviderTests\SearchFixture.cs" />
     <Compile Include="ProviderTests\SearchProviderTests\PerformSearchFixture.cs" />
     <Compile Include="ProviderTests\SearchProviderTests\ProcessSearchResultsFixture.cs" />

NzbDrone.Core.Test/ProviderTests/SearchProviderTests/ProcessDailySearchResultsFixture.cs

@@ -0,0 +1,278 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using FizzWare.NBuilder;
+using FluentAssertions;
+using Moq;
+using NUnit.Framework;
+using NzbDrone.Core.Model;
+using NzbDrone.Core.Model.Notification;
+using NzbDrone.Core.Providers;
+using NzbDrone.Core.Providers.Indexer;
+using NzbDrone.Core.Repository;
+using NzbDrone.Core.Repository.Quality;
+using NzbDrone.Core.Test.Framework;
+using NzbDrone.Test.Common;
+using NzbDrone.Test.Common.AutoMoq;
+
+namespace NzbDrone.Core.Test.ProviderTests.SearchProviderTests
+{
+    [TestFixture]
+    // ReSharper disable InconsistentNaming
+    public class ProcessDailySearchResultsFixture : CoreTest
+    {
+        private Series _matchingSeries = null;
+        private Series _mismatchedSeries = null;
+        private Series _nullSeries = null;
+
+        [SetUp]
+        public void setup()
+        {
+            _matchingSeries = Builder<Series>.CreateNew()
+                .With(s => s.SeriesId = 79488)
+                .With(s => s.Title = "30 Rock")
+                .Build();
+
+            _mismatchedSeries = Builder<Series>.CreateNew()
+                .With(s => s.SeriesId = 12345)
+                .With(s => s.Title = "Not 30 Rock")
+                .Build();
+        }
+
+        private void WithMatchingSeries()
+        {
+            Mocker.GetMock<SeriesProvider>()
+                .Setup(s => s.FindSeries(It.IsAny<string>())).Returns(_matchingSeries);
+        }
+
+        private void WithMisMatchedSeries()
+        {
+            Mocker.GetMock<SeriesProvider>()
+                .Setup(s => s.FindSeries(It.IsAny<string>())).Returns(_mismatchedSeries);
+        }
+
+        private void WithNullSeries()
+        {
+            Mocker.GetMock<SeriesProvider>()
+                .Setup(s => s.FindSeries(It.IsAny<string>())).Returns(_nullSeries);
+        }
+
+        private void WithSuccessfulDownload()
+        {
+            Mocker.GetMock<DownloadProvider>()
+                .Setup(s => s.DownloadReport(It.IsAny<EpisodeParseResult>()))
+                .Returns(true);
+        }
+
+        private void WithFailingDownload()
+        {
+            Mocker.GetMock<DownloadProvider>()
+                .Setup(s => s.DownloadReport(It.IsAny<EpisodeParseResult>()))
+                .Returns(false);
+        }
+
+        private void WithQualityNeeded()
+        {
+            Mocker.GetMock<InventoryProvider>()
+                .Setup(s => s.IsQualityNeeded(It.IsAny<EpisodeParseResult>()))
+                .Returns(true);
+        }
+
+        private void WithQualityNotNeeded()
+        {
+            Mocker.GetMock<InventoryProvider>()
+                .Setup(s => s.IsQualityNeeded(It.IsAny<EpisodeParseResult>()))
+                .Returns(false);
+        }
+
+        [Test]
+        public void processSearchResults_higher_quality_should_be_called_first()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(5)
+                .All()
+                .With(c => c.AirDate = DateTime.Today)
+                .With(c => c.Quality = new Quality(QualityTypes.DVD, true))
+                .Random(1)
+                .With(c => c.Quality = new Quality(QualityTypes.Bluray1080p, true))
+                .Build();
+
+            WithMatchingSeries();
+            WithSuccessfulDownload();
+
+            Mocker.GetMock<InventoryProvider>()
+                .Setup(s => s.IsQualityNeeded(It.Is<EpisodeParseResult>(d => d.Quality.QualityType == QualityTypes.Bluray1080p)))
+                .Returns(true);
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeTrue();
+
+            Mocker.GetMock<InventoryProvider>().Verify(c => c.IsQualityNeeded(It.IsAny<EpisodeParseResult>()),
+                                                       Times.Once());
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Once());
+        }
+
+        [Test]
+        public void processSearchResults_when_quality_is_not_needed_should_check_the_rest()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(5)
+                .All()
+                .With(c => c.AirDate = DateTime.Today)
+                .With(c => c.Quality = new Quality(QualityTypes.DVD, true))
+                .Build();
+
+            WithMatchingSeries();
+            WithQualityNotNeeded();
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeFalse();
+
+            Mocker.GetMock<InventoryProvider>().Verify(c => c.IsQualityNeeded(It.IsAny<EpisodeParseResult>()),
+                                                       Times.Exactly(5));
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Never());
+        }
+
+        [Test]
+        public void processSearchResults_should_skip_if_series_is_null()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(5)
+                .All()
+                .With(e => e.AirDate = DateTime.Today)
+                .Build();
+
+            WithNullSeries();
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeFalse();
+
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Never());
+        }
+
+        [Test]
+        public void processSearchResults_should_skip_if_series_is_mismatched()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(5)
+                .All()
+                .With(e => e.AirDate = DateTime.Today)
+                .Build();
+
+            WithMisMatchedSeries();
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeFalse();
+
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Never());
+        }
+
+        [Test]
+        public void processSearchResults_should_return_after_successful_download()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(2)
+                .All()
+                .With(e => e.AirDate = DateTime.Today)
+                .With(c => c.Quality = new Quality(QualityTypes.DVD, true))
+                .Build();
+
+            WithMatchingSeries();
+            WithQualityNeeded();
+            WithSuccessfulDownload();
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeTrue();
+
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Once());
+        }
+
+        [Test]
+        public void processSearchResults_should_try_next_if_download_fails()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(2)
+                .All()
+                .With(e => e.AirDate = DateTime.Today)
+                .With(c => c.Quality = new Quality(QualityTypes.DVD, true))
+                .TheLast(1)
+                .With(c => c.Quality = new Quality(QualityTypes.SDTV, true))
+                .Build();
+
+            WithMatchingSeries();
+            WithQualityNeeded();
+
+            Mocker.GetMock<DownloadProvider>()
+                .Setup(s => s.DownloadReport(It.Is<EpisodeParseResult>(d => d.Quality.QualityType == QualityTypes.DVD)))
+                .Returns(false);
+
+            Mocker.GetMock<DownloadProvider>()
+                .Setup(s => s.DownloadReport(It.Is<EpisodeParseResult>(d => d.Quality.QualityType == QualityTypes.SDTV)))
+                .Returns(true);
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeTrue();
+
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Exactly(2));
+        }
+
+        [Test]
+        public void processSearchResults_should_skip_if_parseResult_does_not_have_airdate()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(5)
+                .All()
+                .With(e => e.AirDate = null)
+                .Build();
+
+            WithMatchingSeries();
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeFalse();
+
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Never());
+        }
+
+        [Test]
+        public void processSearchResults_should_skip_if_parseResult_airdate_does_not_match()
+        {
+            var parseResults = Builder<EpisodeParseResult>.CreateListOfSize(5)
+                .All()
+                .With(e => e.AirDate = DateTime.Today.AddDays(10))
+                .Build();
+
+            WithMatchingSeries();
+
+            //Act
+            var result = Mocker.Resolve<SearchProvider>().ProcessSearchResults(MockNotification, parseResults, _matchingSeries, DateTime.Today);
+
+            //Assert
+            result.Should().BeFalse();
+
+            Mocker.GetMock<DownloadProvider>().Verify(c => c.DownloadReport(It.IsAny<EpisodeParseResult>()),
+                                                      Times.Never());
+        }
+    }
+}

NzbDrone.Core/Providers/SearchProvider.cs

@@ -146,7 +146,10 @@ namespace NzbDrone.Core.Providers
             Logger.Debug("Finished searching all indexers. Total {0}", reports.Count);
             notification.CurrentMessage = "Processing search results";
 
-            if (ProcessSearchResults(notification, reports, series, episode.SeasonNumber, episode.EpisodeNumber).Count == 1)
+            if (!series.IsDaily && ProcessSearchResults(notification, reports, series, episode.SeasonNumber, episode.EpisodeNumber).Count == 1)
+                return true;
+
+            if (series.IsDaily && ProcessSearchResults(notification, reports, series, episode.AirDate.Value))
                 return true;
 
             Logger.Warn("Unable to find {0} in any of indexers.", episode);
@@ -268,6 +271,54 @@ namespace NzbDrone.Core.Providers
             return successes;
         }
 
+        public bool ProcessSearchResults(ProgressNotification notification, IEnumerable<EpisodeParseResult> reports, Series series, DateTime airDate)
+        {
+            foreach (var episodeParseResult in reports.OrderByDescending(c => c.Quality))
+            {
+                try
+                {
+                    Logger.Trace("Analysing report " + episodeParseResult);
+
+                    //Get the matching series
+                    episodeParseResult.Series = _seriesProvider.FindSeries(episodeParseResult.CleanTitle);
+
+                    //If series is null or doesn't match the series we're looking for return
+                    if (episodeParseResult.Series == null || episodeParseResult.Series.SeriesId != series.SeriesId)
+                        continue;
+
+                    //If parse result doesn't have an air date or it doesn't match passed in airdate, skip the report.
+                    if (!episodeParseResult.AirDate.HasValue || episodeParseResult.AirDate.Value.Date != airDate.Date)
+                        continue;
+
+                    if (_inventoryProvider.IsQualityNeeded(episodeParseResult))
+                    {
+                        Logger.Debug("Found '{0}'. Adding to download queue.", episodeParseResult);
+                        try
+                        {
+                            if (_downloadProvider.DownloadReport(episodeParseResult))
+                            {
+                                notification.CurrentMessage =
+                                        String.Format("{0} - {1} {2}Added to download queue",
+                                                      episodeParseResult.Series.Title, episodeParseResult.AirDate.Value.ToShortDateString(), episodeParseResult.Quality);
+
+                                return true;
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            Logger.ErrorException("Unable to add report to download queue." + episodeParseResult, e);
+                            notification.CurrentMessage = String.Format("Unable to add report to download queue. {0}", episodeParseResult);
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    Logger.ErrorException("An error has occurred while processing parse result items from " + episodeParseResult, e);
+                }
+            }
+            return false;
+        }
+
         private List<int> GetEpisodeNumberPrefixes(IEnumerable<int> episodeNumbers)
         {
             var results = new List<int>();