feat(availability): ✨ Add the option for the *arr to take media availability priority

#5286

Author: tidusjar

src/Ombi.Schedule.Tests/AvailabilityCheckerTests.cs

@@ -4,11 +4,14 @@
 using Moq.AutoMock;
 using NUnit.Framework;
 using Ombi.Core;
+using Ombi.Core.Settings;
 using Ombi.Hubs;
 using Ombi.Notifications.Models;
 using Ombi.Schedule.Jobs;
+using Ombi.Settings.Settings.Models.External;
 using Ombi.Store.Entities;
 using Ombi.Store.Entities.Requests;
+using Ombi.Store.Repository;
 using Ombi.Store.Repository.Requests;
 using Ombi.Tests;
 using System.Collections.Generic;
@@ -177,15 +180,190 @@ public async Task All_One_Episode_Is_Available_In_Request()
                 _mocker.Verify<INotificationHelper>(x => x.Notify(It.Is<NotificationOptions>(x => x.NotificationType == Helpers.NotificationType.PartiallyAvailable && x.RequestId == 1)), Times.Once);
             });
         }
+
+        [Test]
+        public async Task ShouldDeferToRadarr_WhenRadarrDisabled_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = false, ScanForAvailability = true, PrioritizeArrAvailability = true });
+
+            var result = await subject.TestShouldDeferToRadarr(123, false);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToRadarr_WhenScanForAvailabilityDisabled_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = false, PrioritizeArrAvailability = true });
+
+            var result = await subject.TestShouldDeferToRadarr(123, false);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToRadarr_WhenPrioritizeArrAvailabilityDisabled_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = false });
+
+            var result = await subject.TestShouldDeferToRadarr(123, false);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToRadarr_WhenNotInCache_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<RadarrCache>, IQueryable<RadarrCache>>(x => x.GetAll())
+                .Returns(new List<RadarrCache>().AsQueryable().BuildMock());
+
+            var result = await subject.TestShouldDeferToRadarr(123, false);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToRadarr_WhenInCacheWithFile_ReturnsTrue()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<RadarrCache>, IQueryable<RadarrCache>>(x => x.GetAll())
+                .Returns(new List<RadarrCache> { new RadarrCache { TheMovieDbId = 123, HasFile = true, HasRegular = true } }.AsQueryable().BuildMock());
+
+            var result = await subject.TestShouldDeferToRadarr(123, false);
+
+            Assert.That(result, Is.True);
+        }
+
+        [Test]
+        public async Task ShouldDeferToRadarr_4K_WhenInCacheWith4K_ReturnsTrue()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<RadarrCache>, IQueryable<RadarrCache>>(x => x.GetAll())
+                .Returns(new List<RadarrCache> { new RadarrCache { TheMovieDbId = 123, HasFile = true, Has4K = true } }.AsQueryable().BuildMock());
+
+            var result = await subject.TestShouldDeferToRadarr(123, true);
+
+            Assert.That(result, Is.True);
+        }
+
+        [Test]
+        public async Task ShouldDeferToSonarr_WhenSonarrDisabled_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<SonarrSettings>, Task<SonarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new SonarrSettings { Enabled = false, ScanForAvailability = true, PrioritizeArrAvailability = true });
+
+            var result = await subject.TestShouldDeferToSonarr(456);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToSonarr_WhenScanForAvailabilityDisabled_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<SonarrSettings>, Task<SonarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new SonarrSettings { Enabled = true, ScanForAvailability = false, PrioritizeArrAvailability = true });
+
+            var result = await subject.TestShouldDeferToSonarr(456);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToSonarr_WhenPrioritizeArrAvailabilityDisabled_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<SonarrSettings>, Task<SonarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new SonarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = false });
+
+            var result = await subject.TestShouldDeferToSonarr(456);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToSonarr_WhenNoEpisodesInCache_ReturnsFalse()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<SonarrSettings>, Task<SonarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new SonarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<SonarrEpisodeCache>, IQueryable<SonarrEpisodeCache>>(x => x.GetAll())
+                .Returns(new List<SonarrEpisodeCache>().AsQueryable().BuildMock());
+
+            var result = await subject.TestShouldDeferToSonarr(456);
+
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public async Task ShouldDeferToSonarr_WhenEpisodesInCacheWithFile_ReturnsTrue()
+        {
+            var subject = CreateSubjectWithArrDependencies();
+            _mocker.Setup<ISettingsService<SonarrSettings>, Task<SonarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new SonarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<SonarrEpisodeCache>, IQueryable<SonarrEpisodeCache>>(x => x.GetAll())
+                .Returns(new List<SonarrEpisodeCache> { new SonarrEpisodeCache { TvDbId = 456, HasFile = true } }.AsQueryable().BuildMock());
+
+            var result = await subject.TestShouldDeferToSonarr(456);
+
+            Assert.That(result, Is.True);
+        }
+
+        private TestAvailabilityCheckerWithArrSupport CreateSubjectWithArrDependencies()
+        {
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings());
+            _mocker.Setup<ISettingsService<SonarrSettings>, Task<SonarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new SonarrSettings());
+            _mocker.Setup<IExternalRepository<RadarrCache>, IQueryable<RadarrCache>>(x => x.GetAll())
+                .Returns(new List<RadarrCache>().AsQueryable().BuildMock());
+            _mocker.Setup<IExternalRepository<SonarrEpisodeCache>, IQueryable<SonarrEpisodeCache>>(x => x.GetAll())
+                .Returns(new List<SonarrEpisodeCache>().AsQueryable().BuildMock());
+
+            return _mocker.CreateInstance<TestAvailabilityCheckerWithArrSupport>();
+        }
     }
 
 
     public class TestAvailabilityChecker : AvailabilityChecker
     {
-        public TestAvailabilityChecker(ITvRequestRepository tvRequest, INotificationHelper notification, ILogger log, INotificationHubService notificationHubService) : base(tvRequest, notification, log, notificationHubService)
+        public TestAvailabilityChecker(ITvRequestRepository tvRequest, INotificationHelper notification, ILogger log, INotificationHubService notificationHubService) : base(tvRequest, notification, log, notificationHubService, null, null, null, null)
         {
         }
 
         public new Task ProcessTvShow(IQueryable<IBaseMediaServerEpisode> seriesEpisodes, ChildRequests child) => base.ProcessTvShow(seriesEpisodes, child);
     }
+
+    public class TestAvailabilityCheckerWithArrSupport : AvailabilityChecker
+    {
+        public TestAvailabilityCheckerWithArrSupport(
+            ITvRequestRepository tvRequest,
+            INotificationHelper notification,
+            ILogger log,
+            INotificationHubService notificationHubService,
+            ISettingsService<RadarrSettings> radarrSettings,
+            ISettingsService<SonarrSettings> sonarrSettings,
+            IExternalRepository<RadarrCache> radarrCache,
+            IExternalRepository<SonarrEpisodeCache> sonarrEpisodeCache)
+            : base(tvRequest, notification, log, notificationHubService, radarrSettings, sonarrSettings, radarrCache, sonarrEpisodeCache)
+        {
+        }
+
+        public Task<bool> TestShouldDeferToRadarr(int theMovieDbId, bool is4K) => base.ShouldDeferToRadarr(theMovieDbId, is4K);
+        public Task<bool> TestShouldDeferToSonarr(int tvDbId) => base.ShouldDeferToSonarr(tvDbId);
+    }
 }

src/Ombi.Schedule.Tests/PlexAvailabilityCheckerTests.cs

@@ -17,6 +17,8 @@
 using Ombi.Tests;
 using Moq.AutoMock;
 using Ombi.Settings.Settings.Models;
+using Ombi.Settings.Settings.Models.External;
+using Ombi.Core.Settings;
 using Ombi.Notifications.Models;
 
 namespace Ombi.Schedule.Tests
@@ -241,6 +243,126 @@ public async Task ProcessTv_ShouldMark_Episode_Available_By_TitleMatch()
             Assert.True(request.SeasonRequests[0].Episodes[0].Available);
         }
 
+        [Test]
+        public async Task ProcessMovies_ShouldNotMarkAvailable_WhenRadarrPriorityEnabled_AndInRadarrCache()
+        {
+            // Setup Radarr priority
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<RadarrCache>, IQueryable<RadarrCache>>(x => x.GetAll())
+                .Returns(new List<RadarrCache> { new RadarrCache { TheMovieDbId = 123, HasFile = true, HasRegular = true } }.AsQueryable().BuildMock());
+
+            var request = new MovieRequests
+            {
+                ImdbId = "test",
+                TheMovieDbId = 123
+            };
+            _mocker.Setup<IMovieRequestRepository, IQueryable<MovieRequests>>(x => x.GetAll()).Returns(new List<MovieRequests> { request }.AsQueryable());
+            _mocker.Setup<IPlexContentRepository, Task<PlexServerContent>>(x => x.Get("test", ProviderType.ImdbId)).ReturnsAsync(new PlexServerContent());
+
+            await _subject.Execute(null);
+
+            // Should NOT mark as available because Radarr has priority
+            Assert.Multiple(() =>
+            {
+                Assert.That(request.Available, Is.False);
+                Assert.That(request.MarkedAsAvailable, Is.Null);
+            });
+
+            _mocker.Verify<IMovieRequestRepository>(x => x.SaveChangesAsync(), Times.Never);
+            _mocker.Verify<INotificationHelper>(x => x.Notify(It.IsAny<NotificationOptions>()), Times.Never);
+        }
+
+        [Test]
+        public async Task ProcessMovies_ShouldMarkAvailable_WhenRadarrPriorityDisabled_AndInPlex()
+        {
+            // Setup Radarr priority disabled
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = false });
+
+            var request = new MovieRequests
+            {
+                ImdbId = "test"
+            };
+            _mocker.Setup<IMovieRequestRepository, IQueryable<MovieRequests>>(x => x.GetAll()).Returns(new List<MovieRequests> { request }.AsQueryable());
+            _mocker.Setup<IPlexContentRepository, Task<PlexServerContent>>(x => x.Get("test", ProviderType.ImdbId)).ReturnsAsync(new PlexServerContent());
+
+            await _subject.Execute(null);
+
+            // Should mark as available because priority is disabled
+            Assert.Multiple(() =>
+            {
+                Assert.That(request.Available, Is.True);
+                Assert.That(request.MarkedAsAvailable, Is.Not.Null);
+            });
+
+            _mocker.Verify<IMovieRequestRepository>(x => x.SaveChangesAsync(), Times.Once);
+            _mocker.Verify<INotificationHelper>(x => x.Notify(It.IsAny<NotificationOptions>()), Times.Once);
+        }
+
+        [Test]
+        public async Task ProcessMovies_ShouldMarkAvailable_WhenRadarrPriorityEnabled_ButNotInRadarrCache()
+        {
+            // Setup Radarr priority enabled but content not in cache
+            _mocker.Setup<ISettingsService<RadarrSettings>, Task<RadarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new RadarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<RadarrCache>, IQueryable<RadarrCache>>(x => x.GetAll())
+                .Returns(new List<RadarrCache>().AsQueryable().BuildMock());
+
+            var request = new MovieRequests
+            {
+                ImdbId = "test",
+                TheMovieDbId = 123
+            };
+            _mocker.Setup<IMovieRequestRepository, IQueryable<MovieRequests>>(x => x.GetAll()).Returns(new List<MovieRequests> { request }.AsQueryable());
+            _mocker.Setup<IPlexContentRepository, Task<PlexServerContent>>(x => x.Get("test", ProviderType.ImdbId)).ReturnsAsync(new PlexServerContent());
+
+            await _subject.Execute(null);
+
+            // Should mark as available because content is not in Radarr cache
+            Assert.Multiple(() =>
+            {
+                Assert.That(request.Available, Is.True);
+                Assert.That(request.MarkedAsAvailable, Is.Not.Null);
+            });
+
+            _mocker.Verify<IMovieRequestRepository>(x => x.SaveChangesAsync(), Times.Once);
+            _mocker.Verify<INotificationHelper>(x => x.Notify(It.IsAny<NotificationOptions>()), Times.Once);
+        }
+
+        [Test]
+        public async Task ProcessTv_ShouldNotMarkAvailable_WhenSonarrPriorityEnabled_AndInSonarrCache()
+        {
+            // Setup Sonarr priority
+            _mocker.Setup<ISettingsService<SonarrSettings>, Task<SonarrSettings>>(x => x.GetSettingsAsync())
+                .ReturnsAsync(new SonarrSettings { Enabled = true, ScanForAvailability = true, PrioritizeArrAvailability = true });
+            _mocker.Setup<IExternalRepository<SonarrEpisodeCache>, IQueryable<SonarrEpisodeCache>>(x => x.GetAll())
+                .Returns(new List<SonarrEpisodeCache> { new SonarrEpisodeCache { TvDbId = 99, HasFile = true } }.AsQueryable().BuildMock());
+
+            var request = CreateChildRequest(null, 33, 99);
+            _mocker.Setup<ITvRequestRepository, IQueryable<ChildRequests>>(x => x.GetChild()).Returns(new List<ChildRequests> { request }.AsQueryable().BuildMock());
+            _mocker.Setup<IPlexContentRepository, IQueryable<IMediaServerEpisode>>(x => x.GetAllEpisodes()).Returns(new List<PlexEpisode>
+            {
+                new PlexEpisode
+                {
+                    Series = new PlexServerContent
+                    {
+                        TheMovieDbId = 33.ToString(),
+                        Title = "abc"
+                    },
+                    EpisodeNumber = 1,
+                    SeasonNumber = 2,
+                }
+            }.AsQueryable().BuildMock());
+
+            await _subject.Execute(null);
+
+            // Should NOT mark as available because Sonarr has priority
+            Assert.That(request.SeasonRequests[0].Episodes[0].Available, Is.False);
+            // Save is called at the end of ProcessTv, but episodes should not be marked available
+            _mocker.Verify<ITvRequestRepository>(x => x.Save(), Times.Once);
+        }
+
         private ChildRequests CreateChildRequest(string imdbId, int theMovieDbId, int tvdbId)
         {
             return new ChildRequests