Whole album matching and fingerprinting (#592)

* Cache result of GetAllArtists

* Fixed: Manual import not respecting album import notifications

* Fixed: partial album imports stay in queue, prompting manual import

* Fixed: Allow release if tracks are missing

* Fixed: Be tolerant of missing/extra "The" at start of artist name

* Improve manual import UI

* Omit video tracks from DB entirely

* Revert "faster test packaging in build.sh"

This reverts commit 2723e2a7b8.

-u and -T are not supported on macOS

* Fix tests on linux and macOS

* Actually lint on linux

On linux yarn runs scripts with sh not bash so ** doesn't recursively glob

* Match whole albums

* Option to disable fingerprinting

* Rip out MediaInfo

* Don't split up things that have the same album selected in manual import

* Try to speed up IndentificationService

* More speedups

* Some fixes and increase power of recording id

* Fix NRE when no tags

* Fix NRE when some (but not all) files in a directory have missing tags

* Bump taglib, tidy up tag parsing

* Add a health check

* Remove media info setting

* Tags -> audioTags

* Add some tests where tags are null

* Rename history events

* Add missing method to interface

* Reinstate MediaInfo tags and update info with artist scan

Also adds migration to remove old format media info

* This file no longer exists

* Don't penalise year if missing from tags

* Formatting improvements

* Use correct system newline

* Switch to the netstandard2.0 library to support net 461

* TagLib.File is IDisposable so should be in a using

* Improve filename matching and add tests

* Neater logging of parsed tags

* Fix disk scan tests for new media info update

* Fix quality detection source

* Fix Inexact Artist/Album match

* Add button to clear track mapping

* Fix warning

* Pacify eslint

* Use \ not /

* Fix UI updates

* Fix media covers

Prevent localizing URL propaging back to the metadata object

* Reduce database overhead broadcasting UI updates

* Relax timings a bit to make test pass

* Remove irrelevant tests

* Test framework for identification service

* Fix PreferMissingToBadMatch test case

* Make fingerprinting more robust

* More logging

* Penalize unknown media format and country

* Prefer USA to UK

* Allow Data CD

* Fix exception if fingerprinting fails for all files

* Fix tests

* Fix NRE

* Allow apostrophes and remove accents in filename aggregation

* Address codacy issues

* Cope with old versions of fpcalc and suggest upgrade

* fpcalc health check passes if fingerprinting disabled

* Get the Artist meta with the artist

* Fix the mapper so that lazy loaded lists will be populated on Join

And therefore we can join TrackFiles on Tracks by default and avoid an
extra query

* Rename subtitle -> lyric

* Tidy up MediaInfoFormatter

src/NzbDrone.Core.Test/MediaFiles/MediaFileRepositoryFixture.cs

@@ -5,32 +5,31 @@ using NzbDrone.Core.MediaFiles;
 using NzbDrone.Core.Qualities;
 using NzbDrone.Core.Music;
 using NzbDrone.Core.Test.Framework;
+using System.Collections.Generic;
 
 namespace NzbDrone.Core.Test.MediaFiles
 {
     [TestFixture]
     public class MediaFileRepositoryFixture : DbTest<MediaFileRepository, TrackFile>
     {
-        [Test]
-        public void get_files_by_artist()
+        private Artist artist;
+        private Album album;
+        
+        [SetUp]
+        public void Setup()
         {
-
-            var files = Builder<TrackFile>.CreateListOfSize(10)
-                .All()
-                .With(c => c.Id = 0)
-                .With(c => c.Quality =new QualityModel(Quality.MP3_192))
-                .BuildListOfNew();
-
-            Db.InsertMany(files);
-            Db.All<TrackFile>().Should().HaveCount(10);
+            var meta = Builder<ArtistMetadata>.CreateNew()
+                .With(a => a.Id = 0)
+                .Build();
+            Db.Insert(meta);
             
-            var artist = Builder<Artist>.CreateNew()
-                .With(a => a.ArtistMetadataId = 11)
+            artist = Builder<Artist>.CreateNew()
+                .With(a => a.ArtistMetadataId = meta.Id)
                 .With(a => a.Id = 0)
                 .Build();
             Db.Insert(artist);
 
-            var album = Builder<Album>.CreateNew()
+            album = Builder<Album>.CreateNew()
                 .With(a => a.Id = 0)
                 .With(a => a.ArtistMetadataId = artist.ArtistMetadataId)
                 .Build();
@@ -43,6 +42,15 @@ namespace NzbDrone.Core.Test.MediaFiles
                 .Build();
             Db.Insert(release);
             
+            var files = Builder<TrackFile>.CreateListOfSize(10)
+                .All()
+                .With(c => c.Id = 0)
+                .With(c => c.Quality =new QualityModel(Quality.MP3_192))
+                .TheFirst(4)
+                .With(c => c.AlbumId = album.Id)
+                .BuildListOfNew();
+            Db.InsertMany(files);
+            
             var track = Builder<Track>.CreateListOfSize(10)
                 .TheFirst(1)
                 .With(a => a.TrackFileId = files[1].Id)
@@ -59,16 +67,58 @@ namespace NzbDrone.Core.Test.MediaFiles
                 .With(a => a.AlbumReleaseId = release.Id)
                 .Build();
             Db.InsertMany(track);
+        }
+        
+        [Test]
+        public void get_files_by_artist()
+        {
+            VerifyData();
+            var artistFiles = Subject.GetFilesByArtist(artist.Id);
+            VerifyEagerLoaded(artistFiles);
 
+            artistFiles.Should().HaveCount(4);
+            artistFiles.Should().OnlyContain(c => c.Artist.Value.Id == artist.Id);
+        }
+
+        [Test]
+        public void get_files_by_album()
+        {
+            VerifyData();
+            var files = Subject.GetFilesByAlbum(album.Id);
+            VerifyEagerLoaded(files);
+            
+            files.Should().HaveCount(4);
+            files.Should().OnlyContain(c => c.AlbumId == album.Id);
+        }
+
+        [Test]
+        public void get_files_by_relative_path()
+        {
+            VerifyData();
+            var files = Subject.GetFilesWithRelativePath(artist.Id, "RelativePath2");
+            VerifyEagerLoaded(files);
+            
+            files.Should().HaveCount(1);
+            files.Should().OnlyContain(c => c.AlbumId == album.Id);
+            files.Should().OnlyContain(c => c.RelativePath == "RelativePath2");
+        }
+
+        private void VerifyData()
+        {
             Db.All<Artist>().Should().HaveCount(1);
             Db.All<Album>().Should().HaveCount(1);
             Db.All<Track>().Should().HaveCount(10);
+            Db.All<TrackFile>().Should().HaveCount(10);
+        }
 
-            var artistFiles = Subject.GetFilesByArtist(artist.Id);
-
-            artistFiles.Should().HaveCount(4);
-
-            artistFiles.Should().OnlyContain(c => c.ArtistId == artist.Id);
+        private void VerifyEagerLoaded(List<TrackFile> files)
+        {
+            foreach (var file in files)
+            {
+                file.Album.IsLoaded.Should().BeTrue();
+                file.Artist.IsLoaded.Should().BeTrue();
+                file.Artist.Value.Metadata.IsLoaded.Should().BeTrue();
+            }
         }
     }
 }