Fixed: Cutoff Specification not Respecting Profile Order (#660)

* Fixed: Cutoff Specification not Repsecting Profile Order

* Fixed: Incorrect wording in UpgradeAllowed logging

* Fixed: Change Logic to update if upgrade for any, downgrade for none.

* Fixed: Removed Double Preferred Word Logic

* New: Add Test Cases to Disk Upgrade Spec

* Fixed: Cleanup UpgradableSpecification

* Add ConcatToString extension and fix logging

* Fixed: Enum Naming, Commas

src/NzbDrone.Core.Test/DecisionEngineTests/CutoffSpecificationFixture.cs

@@ -7,6 +7,7 @@ using NzbDrone.Core.Test.Framework;
 using NzbDrone.Core.Languages;
 using NzbDrone.Core.Profiles.Languages;
 using NzbDrone.Core.Test.Languages;
+using System.Collections.Generic;
 
 namespace NzbDrone.Core.Test.DecisionEngineTests
 {
@@ -30,7 +31,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
                  Languages = LanguageFixture.GetDefaultLanguages(Language.English),
                  Cutoff = Language.English
              },
-             new QualityModel(Quality.MP3_192, new Revision(version: 2)), Language.English, NoPreferredWordScore).Should().BeTrue();
+             new List<QualityModel> { new QualityModel(Quality.MP3_192, new Revision(version: 2)) },
+             new List<Language> { Language.English }, NoPreferredWordScore).Should().BeTrue();
         }
 
         [Test]
@@ -47,7 +49,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
                 Languages = LanguageFixture.GetDefaultLanguages(Language.English),
                 Cutoff = Language.English
             },
-            new QualityModel(Quality.MP3_256, new Revision(version: 2)), Language.English, NoPreferredWordScore).Should().BeFalse();
+            new List<QualityModel> { new QualityModel(Quality.MP3_256, new Revision(version: 2)) },
+            new List<Language> { Language.English }, NoPreferredWordScore).Should().BeFalse();
         }
 
         [Test]
@@ -65,7 +68,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
                 Languages = LanguageFixture.GetDefaultLanguages(Language.English),
                 Cutoff = Language.English
             },
-            new QualityModel(Quality.MP3_320, new Revision(version: 2)), Language.English, NoPreferredWordScore).Should().BeFalse();
+            new List<QualityModel> { new QualityModel(Quality.MP3_320, new Revision(version: 2)) },
+            new List<Language> { Language.English }, NoPreferredWordScore).Should().BeFalse();
         }
 
         [Test]
@@ -83,8 +87,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
                 Languages = LanguageFixture.GetDefaultLanguages(Language.English),
                 Cutoff = Language.English
             },
-            new QualityModel(Quality.MP3_320, new Revision(version: 1)),
-            Language.English,
+            new List<QualityModel> { new QualityModel(Quality.MP3_320, new Revision(version: 1)) },
+            new List<Language> { Language.English },
             NoPreferredWordScore,
             new QualityModel(Quality.MP3_320, new Revision(version: 2))).Should().BeTrue();
 
@@ -105,7 +109,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
                 Languages = LanguageFixture.GetDefaultLanguages(Language.English),
                 Cutoff = Language.English
             },
-            new QualityModel(Quality.MP3_320, new Revision(version: 2)), Language.English,
+            new List<QualityModel> { new QualityModel(Quality.MP3_320, new Revision(version: 2)) },
+            new List<Language> { Language.English },
             NoPreferredWordScore,
             new QualityModel(Quality.FLAC, new Revision(version: 2))).Should().BeFalse();
         }
@@ -128,8 +133,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
 
             Subject.CutoffNotMet(_profile,
                 _langProfile,
-                 new QualityModel(Quality.MP3_320, new Revision(version: 2)),
-                 Language.English,
+                 new List<QualityModel> { new QualityModel(Quality.MP3_320, new Revision(version: 2)) },
+                 new List<Language> { Language.English },
                  NoPreferredWordScore,
                  new QualityModel(Quality.FLAC, new Revision(version: 2))).Should().BeTrue();
         }
@@ -153,8 +158,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.CutoffNotMet(
                 _profile,
                 _langProfile,
-                new QualityModel(Quality.MP3_320, new Revision(version: 2)),
-                Language.Spanish,
+                new List<QualityModel> { new QualityModel(Quality.MP3_320, new Revision(version: 2)) },
+                new List<Language> { Language.Spanish },
                 NoPreferredWordScore,
                 new QualityModel(Quality.FLAC, new Revision(version: 2))).Should().BeFalse();
         }
@@ -178,8 +183,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.CutoffNotMet(
                 _profile,
                 _langProfile,
-                new QualityModel(Quality.MP3_320, new Revision(version: 2)),
-                Language.French,
+                new List<QualityModel> { new QualityModel(Quality.MP3_320, new Revision(version: 2)) },
+                new List<Language> { Language.French },
                 NoPreferredWordScore,
                 new QualityModel(Quality.FLAC, new Revision(version: 2))).Should().BeFalse();
         }
@@ -203,8 +208,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.CutoffNotMet(
                 _profile,
                 _langProfile,
-                new QualityModel(Quality.MP3_256, new Revision(version: 2)),
-                Language.French,
+                new List<QualityModel> { new QualityModel(Quality.MP3_256, new Revision(version: 2)) },
+                new List<Language> { Language.French },
                 NoPreferredWordScore,
                 new QualityModel(Quality.FLAC, new Revision(version: 2))).Should().BeTrue();
         }
@@ -228,8 +233,9 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.CutoffNotMet(
                 _profile,
                 _langProfile,
-                new QualityModel(Quality.MP3_256, new Revision(version: 2)),
-                Language.French, NoPreferredWordScore).Should().BeTrue();
+                new List<QualityModel> { new QualityModel(Quality.MP3_256, new Revision(version: 2)) },
+                new List<Language> { Language.French },
+                NoPreferredWordScore).Should().BeTrue();
         }
 
         [Test]
@@ -250,8 +256,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.CutoffNotMet(
                 _profile,
                 _langProfile,
-                new QualityModel(Quality.MP3_320, new Revision(version: 2)),
-                Language.Spanish,
+                new List<QualityModel> { new QualityModel(Quality.MP3_320, new Revision(version: 2)) },
+                new List<Language> { Language.Spanish },
                 NoPreferredWordScore,
                 new QualityModel(Quality.FLAC, new Revision(version: 2)),
                 10).Should().BeTrue();

src/NzbDrone.Core.Test/DecisionEngineTests/RssSync/DelaySpecificationFixture.cs

@@ -96,7 +96,7 @@ namespace NzbDrone.Core.Test.DecisionEngineTests.RssSync
         private void GivenUpgradeForExistingFile()
         {
             Mocker.GetMock<IUpgradableSpecification>()
-                  .Setup(s => s.IsUpgradable(It.IsAny<QualityProfile>(), It.IsAny<LanguageProfile>(), It.IsAny<QualityModel>(), It.IsAny<Language>(), It.IsAny<int>(), It.IsAny<QualityModel>(), It.IsAny<Language>(), It.IsAny<int>()))
+                  .Setup(s => s.IsUpgradable(It.IsAny<QualityProfile>(), It.IsAny<LanguageProfile>(), It.IsAny<List<QualityModel>>(), It.IsAny<List<Language>>(), It.IsAny<int>(), It.IsAny<QualityModel>(), It.IsAny<Language>(), It.IsAny<int>()))
                   .Returns(true);
         }
 

src/NzbDrone.Core.Test/DecisionEngineTests/UpgradeAllowedSpecificationFixture.cs

@@ -0,0 +1,293 @@
+using FluentAssertions;
+using NUnit.Framework;
+using NzbDrone.Core.Profiles.Qualities;
+using NzbDrone.Core.Qualities;
+using NzbDrone.Core.DecisionEngine.Specifications;
+using NzbDrone.Core.Test.Framework;
+using NzbDrone.Core.Languages;
+using NzbDrone.Core.Profiles.Languages;
+using NzbDrone.Core.Test.Languages;
+using System.Collections.Generic;
+
+namespace NzbDrone.Core.Test.DecisionEngineTests
+{
+    [TestFixture]
+    public class UpgradeAllowedSpecificationFixture : CoreTest<UpgradableSpecification>
+    {
+        [Test]
+        public void should_return_false_when_quality_are_the_same_language_is_better_and_upgrade_allowed_is_false_for_language_profile()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English, Language.French),
+                    Cutoff = Language.French,
+                    UpgradeAllowed = false
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.MP3_320),
+                Language.French
+            ).Should().BeFalse();
+        }
+
+        [Test]
+        public void should_return_false_when_quality_is_better_languages_are_the_same_and_upgrade_allowed_is_false_for_quality_profile()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = false
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English),
+                    Cutoff = Language.English,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.FLAC),
+                Language.English
+            ).Should().BeFalse();
+        }
+
+        [Test]
+        public void should_return_true_for_language_upgrade_when_upgrading_is_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English, Language.French),
+                    Cutoff = Language.French,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.MP3_320),
+                Language.French
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_same_language_when_upgrading_is_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English, Language.French),
+                    Cutoff = Language.French,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.MP3_320),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_same_language_when_upgrading_is_not_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English, Language.French),
+                    Cutoff = Language.French,
+                    UpgradeAllowed = false
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.French },
+                new QualityModel(Quality.MP3_320),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_lower_language_when_upgrading_is_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English, Language.French),
+                    Cutoff = Language.French,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.French },
+                new QualityModel(Quality.MP3_320),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_lower_language_when_upgrading_is_not_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English, Language.French),
+                    Cutoff = Language.French,
+                    UpgradeAllowed = false
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.French },
+                new QualityModel(Quality.MP3_320),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_quality_upgrade_when_upgrading_is_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English),
+                    Cutoff = Language.English,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.FLAC),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_same_quality_when_upgrading_is_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English),
+                    Cutoff = Language.English,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.MP3_320),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_same_quality_when_upgrading_is_not_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = false
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English),
+                    Cutoff = Language.English,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.MP3_320),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_lower_quality_when_upgrading_is_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = true
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English),
+                    Cutoff = Language.English,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel> { new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.MP3_256),
+                Language.English
+            ).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_for_lower_quality_when_upgrading_is_not_allowed()
+        {
+            Subject.IsUpgradeAllowed(
+                new QualityProfile
+                {
+                    Cutoff = Quality.FLAC.Id,
+                    Items = Qualities.QualityFixture.GetDefaultQualities(),
+                    UpgradeAllowed = false
+                },
+                new LanguageProfile
+                {
+                    Languages = LanguageFixture.GetDefaultLanguages(Language.English),
+                    Cutoff = Language.English,
+                    UpgradeAllowed = true
+                },
+                new List<QualityModel>{ new QualityModel(Quality.MP3_320) },
+                new List<Language> { Language.English },
+                new QualityModel(Quality.MP3_256),
+                Language.English
+            ).Should().BeTrue();
+        }
+    }
+}

src/NzbDrone.Core.Test/DecisionEngineTests/UpgradeDiskSpecificationFixture.cs

@@ -34,8 +34,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             _firstFile = new TrackFile { Quality = new QualityModel(Quality.FLAC, new Revision(version: 2)), DateAdded = DateTime.Now, Language = Language.English };
             _secondFile = new TrackFile { Quality = new QualityModel(Quality.FLAC, new Revision(version: 2)), DateAdded = DateTime.Now, Language = Language.English };
 
-            var singleEpisodeList = new List<Album> { new Album {}};
-            var doubleEpisodeList = new List<Album> { new Album {}, new Album {}, new Album {} };
+            var singleAlbumList = new List<Album> { new Album {}};
+            var doubleAlbumList = new List<Album> { new Album {}, new Album {}, new Album {} };
 
             var languages = Languages.LanguageFixture.GetDefaultLanguages(Language.English, Language.Spanish);
 
@@ -66,14 +66,14 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             {
                 Artist = fakeArtist,
                 ParsedAlbumInfo = new ParsedAlbumInfo { Quality = new QualityModel(Quality.MP3_256, new Revision(version: 2)), Language = Language.English },
-                Albums = doubleEpisodeList
+                Albums = doubleAlbumList
             };
 
             _parseResultSingle = new RemoteAlbum
             {
                 Artist = fakeArtist,
                 ParsedAlbumInfo = new ParsedAlbumInfo { Quality = new QualityModel(Quality.MP3_256, new Revision(version: 2)), Language = Language.English },
-                Albums = singleEpisodeList
+                Albums = singleAlbumList
             };
 
         }
@@ -127,9 +127,10 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
         }
 
         [Test]
-        public void should_be_upgradable_if_album_is_upgradable()
+        public void should_be_upgradable_if_all_files_are_upgradable()
         {
             WithFirstFileUpgradable();
+            WithSecondFileUpgradable();
             Subject.IsSatisfiedBy(_parseResultSingle, null).Accepted.Should().BeTrue();
         }
 
@@ -137,6 +138,7 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
         public void should_not_be_upgradable_if_qualities_are_the_same()
         {
             _firstFile.Quality = new QualityModel(Quality.MP3_320);
+            _secondFile.Quality = new QualityModel(Quality.MP3_320);
             _parseResultSingle.ParsedAlbumInfo.Quality = new QualityModel(Quality.MP3_320);
             Subject.IsSatisfiedBy(_parseResultSingle, null).Accepted.Should().BeFalse();
         }
@@ -146,5 +148,21 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
         {
             Subject.IsSatisfiedBy(_parseResultSingle, null).Accepted.Should().BeFalse();
         }
+
+        [Test]
+        public void should_be_true_if_some_tracks_are_upgradable_and_none_are_downgrades()
+        {
+            WithFirstFileUpgradable();
+            _parseResultSingle.ParsedAlbumInfo.Quality = _secondFile.Quality;
+            Subject.IsSatisfiedBy(_parseResultSingle, null).Accepted.Should().BeTrue();
+        }
+
+        [Test]
+        public void should_be_false_if_some_tracks_are_upgradable_and_some_are_downgrades()
+        {
+            WithFirstFileUpgradable();
+            _parseResultSingle.ParsedAlbumInfo.Quality = new QualityModel(Quality.MP3_320);
+            Subject.IsSatisfiedBy(_parseResultSingle, null).Accepted.Should().BeFalse();
+        }
     }
 }

src/NzbDrone.Core.Test/DecisionEngineTests/UpgradeSpecificationFixture.cs

@@ -8,6 +8,7 @@ using NzbDrone.Core.Test.Framework;
 using NzbDrone.Core.Languages;
 using NzbDrone.Core.Profiles.Languages;
 using NzbDrone.Core.Test.Languages;
+using System.Collections.Generic;
 
 namespace NzbDrone.Core.Test.DecisionEngineTests
 {
@@ -65,8 +66,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.IsUpgradable(
                         profile,
                         langProfile,
-                        new QualityModel(current, new Revision(version: currentVersion)),
-                        Language.English,
+                        new List<QualityModel> { new QualityModel(current, new Revision(version: currentVersion)) },
+                        new List<Language> { Language.English },
                         NoPreferredWordScore,
                         new QualityModel(newQuality, new Revision(version: newVersion)),
                         Language.English,
@@ -96,8 +97,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.IsUpgradable(
                         profile,
                         langProfile,
-                        new QualityModel(current, new Revision(version: currentVersion)),
-                        currentLanguage,
+                        new List<QualityModel> { new QualityModel(current, new Revision(version: currentVersion)) },
+                        new List<Language> { currentLanguage },
                         NoPreferredWordScore,
                         new QualityModel(newQuality, new Revision(version: newVersion)),
                         newLanguage,
@@ -125,8 +126,8 @@ namespace NzbDrone.Core.Test.DecisionEngineTests
             Subject.IsUpgradable(
                         profile,
                         langProfile,
-                        new QualityModel(Quality.MP3_256, new Revision(version: 2)),
-                        Language.English,
+                        new List<QualityModel> { new QualityModel(Quality.MP3_256, new Revision(version: 2)) },
+                        new List<Language> { Language.English },
                         NoPreferredWordScore,
                         new QualityModel(Quality.MP3_256, new Revision(version: 1)),
                         Language.English,