Fixed: Only one version of an album may be approved for import

src/NzbDrone.Core.Test/MediaFiles/TrackImport/ImportDecisionMakerFixture.cs

@@ -272,6 +272,41 @@ namespace NzbDrone.Core.Test.MediaFiles.TrackImport
             result.Single().Approved.Should().BeTrue();
         }
 
+        [Test]
+        public void should_reject_more_than_one_version_of_an_album()
+        {
+            GivenAugmentationSuccess();
+
+            GivenAudioFiles(new[]
+            {
+                @"C:\Test\Unsorted\release1\track1.mp3".AsOsAgnostic(),
+                @"C:\Test\Unsorted\release2\track1.mp3".AsOsAgnostic()
+            });
+
+            Mocker.GetMock<IIdentificationService>()
+                .Setup(s => s.Identify(It.IsAny<List<LocalTrack>>(), It.IsAny<IdentificationOverrides>(), It.IsAny<ImportDecisionMakerConfig>()))
+                .Returns((List<LocalTrack> tracks, IdentificationOverrides idOverrides, ImportDecisionMakerConfig config) =>
+                {
+                    var ret1 = new LocalAlbumRelease(tracks.Take(1).ToList());
+                    ret1.AlbumRelease = _albumRelease;
+
+                    var ret2 = new LocalAlbumRelease(tracks.Skip(1).ToList());
+                    var albumRelease2 = Builder<AlbumRelease>.CreateNew()
+                        .With(x => x.Album = _album)
+                        .With(x => x.ForeignReleaseId = "anotherid")
+                        .Build();
+                    ret2.AlbumRelease = albumRelease2;
+
+                    return new List<LocalAlbumRelease> { ret1, ret2 };
+                });
+
+            GivenSpecifications(_pass1);
+
+            var result = Subject.GetImportDecisions(_fileInfos, null, null, _idConfig);
+            result.Count(x => x.Approved).Should().Be(1);
+            result.Count(x => !x.Approved).Should().Be(1);
+        }
+
         [Test]
         public void should_have_same_number_of_rejections_as_specs_that_failed()
         {

src/NzbDrone.Core/MediaFiles/TrackImport/ImportDecisionMaker.cs

@@ -141,8 +141,8 @@ namespace NzbDrone.Core.MediaFiles.TrackImport
 
         public List<ImportDecision<LocalTrack>> GetImportDecisions(List<IFileInfo> musicFiles, IdentificationOverrides idOverrides, ImportDecisionMakerInfo itemInfo, ImportDecisionMakerConfig config)
         {
-            idOverrides = idOverrides ?? new IdentificationOverrides();
-            itemInfo = itemInfo ?? new ImportDecisionMakerInfo();
+            idOverrides ??= new IdentificationOverrides();
+            itemInfo ??= new ImportDecisionMakerInfo();
 
             var trackData = GetLocalTracks(musicFiles, itemInfo.DownloadClientItem, itemInfo.ParsedTrackInfo, config.Filter);
             var localTracks = trackData.Item1;
@@ -152,24 +152,44 @@ namespace NzbDrone.Core.MediaFiles.TrackImport
 
             var releases = _identificationService.Identify(localTracks, idOverrides, config);
 
-            foreach (var release in releases)
+            var albums = releases.GroupBy(x => x.AlbumRelease?.Album?.Value.ForeignAlbumId);
+
+            // group releases that are identified as the same album
+            foreach (var album in albums)
             {
-                // make sure the appropriate quality profile is set for the release artist
-                // in case it's a new artist
-                EnsureData(release);
-                release.NewDownload = config.NewDownload;
+                var albumDecisions = new List<ImportDecision<LocalAlbumRelease>>();
 
-                var releaseDecision = GetDecision(release, itemInfo.DownloadClientItem);
+                foreach (var release in album)
+                {
+                    // make sure the appropriate quality profile is set for the release artist
+                    // in case it's a new artist
+                    EnsureData(release);
+                    release.NewDownload = config.NewDownload;
 
-                foreach (var localTrack in release.LocalTracks)
+                    albumDecisions.Add(GetDecision(release, itemInfo.DownloadClientItem));
+                }
+
+                // if multiple album releases accepted, reject all but one with most tracks
+                var acceptedReleases = albumDecisions
+                    .Where(x => x.Approved)
+                    .OrderByDescending(x => x.Item.TrackCount);
+                foreach (var decision in acceptedReleases.Skip(1))
                 {
-                    if (releaseDecision.Approved)
-                    {
-                        decisions.AddIfNotNull(GetDecision(localTrack, itemInfo.DownloadClientItem));
-                    }
-                    else
+                    decision.Reject(new Rejection("Multiple versions of an album not supported"));
+                }
+
+                foreach (var releaseDecision in albumDecisions)
+                {
+                    foreach (var localTrack in releaseDecision.Item.LocalTracks)
                     {
-                        decisions.Add(new ImportDecision<LocalTrack>(localTrack, releaseDecision.Rejections.ToArray()));
+                        if (releaseDecision.Approved)
+                        {
+                            decisions.AddIfNotNull(GetDecision(localTrack, itemInfo.DownloadClientItem));
+                        }
+                        else
+                        {
+                            decisions.Add(new ImportDecision<LocalTrack>(localTrack, releaseDecision.Rejections.ToArray()));
+                        }
                     }
                 }
             }