Address review comments

Clean up style
Fix references in class summaries
Combine Where+FirstOrDefault queries
Break up large method, long lines
Add validation on file extension
Apply test naming conventions
Extract mock of Movie class, comment on why not mocking interface

Co-authored-by: Cody Robibero <cody@robibe.ro>
Co-authored-by: Claus Vium <cvium@users.noreply.github.com>

2 files changed, 138 insertions, 125 deletions

diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
index fcea1532a..b194e3885 100644
--- a/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/EmbeddedImageProviderTests.cs
@@ -17,38 +17,37 @@ namespace Jellyfin.Providers.Tests.MediaInfo
 {
     public class EmbeddedImageProviderTests
     {
-        public static TheoryData<BaseItem> GetSupportedImages_Empty_TestData =>
-            new ()
+        private static TheoryData<BaseItem> GetSupportedImages_UnsupportedBaseItems_ReturnsEmpty_TestData()
+        {
+            return new ()
             {
                 new AudioBook(),
                 new BoxSet(),
                 new Series(),
                 new Season(),
             };
-
-        public static TheoryData<BaseItem, IEnumerable<ImageType>> GetSupportedImages_Populated_TestData =>
-            new TheoryData<BaseItem, IEnumerable<ImageType>>
-            {
-                { new Episode(), new List<ImageType> { ImageType.Primary } },
-                { new Movie(), new List<ImageType> { ImageType.Logo, ImageType.Backdrop, ImageType.Primary } },
-            };
-
-        private EmbeddedImageProvider GetEmbeddedImageProvider(IMediaEncoder? mediaEncoder)
-        {
-            return new EmbeddedImageProvider(mediaEncoder);
         }
 
         [Theory]
-        [MemberData(nameof(GetSupportedImages_Empty_TestData))]
-        public void GetSupportedImages_Empty(BaseItem item)
+        [MemberData(nameof(GetSupportedImages_UnsupportedBaseItems_ReturnsEmpty_TestData))]
+        public void GetSupportedImages_UnsupportedBaseItems_ReturnsEmpty(BaseItem item)
         {
             var embeddedImageProvider = GetEmbeddedImageProvider(null);
-            Assert.False(embeddedImageProvider.GetSupportedImages(item).Any());
+            Assert.Empty(embeddedImageProvider.GetSupportedImages(item));
+        }
+
+        private static TheoryData<BaseItem, IEnumerable<ImageType>> GetSupportedImages_SupportedBaseItems_ReturnsPopulated_TestData()
+        {
+            return new TheoryData<BaseItem, IEnumerable<ImageType>>
+            {
+                { new Episode(), new List<ImageType> { ImageType.Primary } },
+                { new Movie(), new List<ImageType> { ImageType.Logo, ImageType.Backdrop, ImageType.Primary } },
+            };
         }
 
         [Theory]
-        [MemberData(nameof(GetSupportedImages_Populated_TestData))]
-        public void GetSupportedImages_Populated(BaseItem item, IEnumerable<ImageType> expected)
+        [MemberData(nameof(GetSupportedImages_SupportedBaseItems_ReturnsPopulated_TestData))]
+        public void GetSupportedImages_SupportedBaseItems_ReturnsPopulated(BaseItem item, IEnumerable<ImageType> expected)
         {
             var embeddedImageProvider = GetEmbeddedImageProvider(null);
             var actual = embeddedImageProvider.GetSupportedImages(item);
@@ -56,56 +55,34 @@ namespace Jellyfin.Providers.Tests.MediaInfo
         }
 
         [Fact]
-        public async void GetImage_Empty_NoStreams()
+        public async void GetImage_InputWithNoStreams_ReturnsNoImage()
         {
             var embeddedImageProvider = GetEmbeddedImageProvider(null);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaSources(It.IsAny<bool>()))
-                .Returns(new List<MediaSourceInfo>());
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>());
+            var input = GetMovie(new List<MediaAttachment>(), new List<MediaStream>());
 
-            var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.False(actual.HasImage);
         }
 
         [Fact]
-        public async void GetImage_Empty_NoLabeledAttachments()
+        public async void GetImage_InputWithUnlabeledAttachments_ReturnsNoImage()
         {
             var embeddedImageProvider = GetEmbeddedImageProvider(null);
 
-            var input = new Mock<Movie>();
             // add an attachment without a filename - has a list to look through but finds nothing
-            input.Setup(movie => movie.GetMediaSources(It.IsAny<bool>()))
-                .Returns(new List<MediaSourceInfo> { new () { MediaAttachments = new List<MediaAttachment> { new () } } });
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>());
+            var input = GetMovie(
+                new List<MediaAttachment> { new () },
+                new List<MediaStream>());
 
-            var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.False(actual.HasImage);
         }
 
         [Fact]
-        public async void GetImage_Empty_NoEmbeddedLabeledBackdrop()
-        {
-            var embeddedImageProvider = GetEmbeddedImageProvider(null);
-
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaSources(It.IsAny<bool>()))
-                .Returns(new List<MediaSourceInfo>());
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream> { new () { Type = MediaStreamType.EmbeddedImage } });
-
-            var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
-            Assert.NotNull(actual);
-            Assert.False(actual.HasImage);
-        }
-
-        [Fact]
-        public async void GetImage_Attached()
+        public async void GetImage_InputWithLabeledAttachments_ReturnsCorrectSelection()
         {
             // first tests file extension detection, second uses mimetype, third defaults to jpg
             MediaAttachment sampleAttachment1 = new () { FileName = "clearlogo.png", Index = 1 };
@@ -124,25 +101,23 @@ namespace Jellyfin.Providers.Tests.MediaInfo
                 .Returns(Task.FromResult(targetPath3));
             var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaSources(It.IsAny<bool>()))
-                .Returns(new List<MediaSourceInfo> { new () { MediaAttachments = new List<MediaAttachment> { sampleAttachment1, sampleAttachment2, sampleAttachment3 } } });
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>());
+            var input = GetMovie(
+                new List<MediaAttachment> { sampleAttachment1, sampleAttachment2, sampleAttachment3 },
+                new List<MediaStream>());
 
-            var actualLogo = await embeddedImageProvider.GetImage(input.Object, ImageType.Logo, CancellationToken.None);
+            var actualLogo = await embeddedImageProvider.GetImage(input, ImageType.Logo, CancellationToken.None);
             Assert.NotNull(actualLogo);
             Assert.True(actualLogo.HasImage);
             Assert.Equal(targetPath1, actualLogo.Path);
             Assert.Equal(ImageFormat.Png, actualLogo.Format);
 
-            var actualBackdrop = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
+            var actualBackdrop = await embeddedImageProvider.GetImage(input, ImageType.Backdrop, CancellationToken.None);
             Assert.NotNull(actualBackdrop);
             Assert.True(actualBackdrop.HasImage);
             Assert.Equal(targetPath2, actualBackdrop.Path);
             Assert.Equal(ImageFormat.Bmp, actualBackdrop.Format);
 
-            var actualPrimary = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actualPrimary = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actualPrimary);
             Assert.True(actualPrimary.HasImage);
             Assert.Equal(targetPath3, actualPrimary.Path);
@@ -150,23 +125,35 @@ namespace Jellyfin.Providers.Tests.MediaInfo
         }
 
         [Fact]
-        public async void GetImage_EmbeddedDefault()
+        public async void GetImage_InputWithUnlabeledEmbeddedImages_BackdropReturnsNoImage()
+        {
+            var embeddedImageProvider = GetEmbeddedImageProvider(null);
+
+            var input = GetMovie(
+                new List<MediaAttachment>(),
+                new List<MediaStream> { new () { Type = MediaStreamType.EmbeddedImage } });
+
+            var actual = await embeddedImageProvider.GetImage(input, ImageType.Backdrop, CancellationToken.None);
+            Assert.NotNull(actual);
+            Assert.False(actual.HasImage);
+        }
+
+        [Fact]
+        public async void GetImage_InputWithUnlabeledEmbeddedImages_PrimaryReturnsImage()
         {
             MediaStream sampleStream = new () { Type = MediaStreamType.EmbeddedImage, Index = 1 };
             string targetPath = "path";
 
             var mediaEncoder = new Mock<IMediaEncoder>(MockBehavior.Strict);
-            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), sampleStream, 1, "jpg", CancellationToken.None))
+            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), sampleStream, 1, ".jpg", CancellationToken.None))
                 .Returns(Task.FromResult(targetPath));
             var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaSources(It.IsAny<bool>()))
-                .Returns(new List<MediaSourceInfo>());
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>() { sampleStream });
+            var input = GetMovie(
+                new List<MediaAttachment>(),
+                new List<MediaStream> { sampleStream });
 
-            var actual = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.True(actual.HasImage);
             Assert.Equal(targetPath, actual.Path);
@@ -174,7 +161,7 @@ namespace Jellyfin.Providers.Tests.MediaInfo
         }
 
         [Fact]
-        public async void GetImage_EmbeddedSelection()
+        public async void GetImage_InputWithLabeledEmbeddedImages_ReturnsCorrectSelection()
         {
             // primary is second stream to ensure it's not defaulting, backdrop is first
             MediaStream sampleStream1 = new () { Type = MediaStreamType.EmbeddedImage, Index = 1, Comment = "backdrop" };
@@ -183,29 +170,47 @@ namespace Jellyfin.Providers.Tests.MediaInfo
             string targetPath2 = "path2.jpg";
 
             var mediaEncoder = new Mock<IMediaEncoder>(MockBehavior.Strict);
-            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), sampleStream1, 1, "jpg", CancellationToken.None))
+            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), sampleStream1, 1, ".jpg", CancellationToken.None))
                 .Returns(Task.FromResult(targetPath1));
-            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), sampleStream2, 2, "jpg", CancellationToken.None))
+            mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), sampleStream2, 2, ".jpg", CancellationToken.None))
                 .Returns(Task.FromResult(targetPath2));
             var embeddedImageProvider = GetEmbeddedImageProvider(mediaEncoder.Object);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaSources(It.IsAny<bool>()))
-                .Returns(new List<MediaSourceInfo>());
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream> { sampleStream1, sampleStream2 });
+            var input = GetMovie(
+                new List<MediaAttachment>(),
+                new List<MediaStream> { sampleStream1, sampleStream2 });
 
-            var actualPrimary = await embeddedImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actualPrimary = await embeddedImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actualPrimary);
             Assert.True(actualPrimary.HasImage);
             Assert.Equal(targetPath2, actualPrimary.Path);
             Assert.Equal(ImageFormat.Jpg, actualPrimary.Format);
 
-            var actualBackdrop = await embeddedImageProvider.GetImage(input.Object, ImageType.Backdrop, CancellationToken.None);
+            var actualBackdrop = await embeddedImageProvider.GetImage(input, ImageType.Backdrop, CancellationToken.None);
             Assert.NotNull(actualBackdrop);
             Assert.True(actualBackdrop.HasImage);
             Assert.Equal(targetPath1, actualBackdrop.Path);
             Assert.Equal(ImageFormat.Jpg, actualBackdrop.Format);
         }
+
+        private static EmbeddedImageProvider GetEmbeddedImageProvider(IMediaEncoder? mediaEncoder)
+        {
+            return new EmbeddedImageProvider(mediaEncoder);
+        }
+
+        private static Movie GetMovie(List<MediaAttachment> mediaAttachments, List<MediaStream> mediaStreams)
+        {
+            // Mocking IMediaSourceManager GetMediaAttachments and GetMediaStreams instead of mocking Movie works, but
+            // has concurrency problems between this and VideoImageProviderTests due to BaseItem.MediaSourceManager
+            // being static
+            var movie = new Mock<Movie>();
+
+            movie.Setup(item => item.GetMediaSources(It.IsAny<bool>()))
+                .Returns(new List<MediaSourceInfo> { new () { MediaAttachments = mediaAttachments } } );
+            movie.Setup(item => item.GetMediaStreams())
+                .Returns(mediaStreams);
+
+            return movie.Object;
+        }
     }
 }
diff --git a/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
index 9a5cd79bb..0f51a2b8f 100644
--- a/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
+++ b/tests/Jellyfin.Providers.Tests/MediaInfo/VideoImageProviderTests.cs
@@ -16,56 +16,51 @@ namespace Jellyfin.Providers.Tests.MediaInfo
 {
     public class VideoImageProviderTests
     {
-        private VideoImageProvider GetVideoImageProvider(IMediaEncoder? mediaEncoder)
-        {
-            // strict to ensure this isn't accidentally used where a prepared mock is intended
-            mediaEncoder ??= new Mock<IMediaEncoder>(MockBehavior.Strict).Object;
-            return new VideoImageProvider(mediaEncoder, new NullLogger<VideoImageProvider>());
-        }
-
         [Fact]
-        public async void GetImage_Empty_IsPlaceholder()
+        public async void GetImage_InputIsPlaceholder_ReturnsNoImage()
         {
             var videoImageProvider = GetVideoImageProvider(null);
 
-            var input = new Mock<Movie>();
-            input.Object.IsPlaceHolder = true;
+            var input = new Movie
+            {
+                IsPlaceHolder = true
+            };
 
-            var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.False(actual.HasImage);
         }
 
         [Fact]
-        public async void GetImage_Empty_NoDefaultVideoStream()
+        public async void GetImage_NoDefaultVideoStream_ReturnsNoImage()
         {
             var videoImageProvider = GetVideoImageProvider(null);
 
-            var input = new Mock<Movie>();
+            var input = new Movie
+            {
+                DefaultVideoStreamIndex = null
+            };
 
-            var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.False(actual.HasImage);
         }
 
         [Fact]
-        public async void GetImage_Empty_DefaultSet_NoVideoStream()
+        public async void GetImage_DefaultSetButNoVideoStream_ReturnsNoImage()
         {
             var videoImageProvider = GetVideoImageProvider(null);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>());
             // set a default index but don't put anything there (invalid input, but provider shouldn't break)
-            input.Object.DefaultVideoStreamIndex = 1;
+            var input = GetMovie(0, null, new List<MediaStream>());
 
-            var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.False(actual.HasImage);
         }
 
         [Fact]
-        public async void GetImage_Extract_DefaultStream()
+        public async void GetImage_DefaultSetMultipleVideoStreams_ReturnsDefaultStreamImage()
         {
             MediaStream firstStream = new () { Type = MediaStreamType.Video, Index = 0 };
             MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 1 };
@@ -78,14 +73,9 @@ namespace Jellyfin.Providers.Tests.MediaInfo
                 .Returns(Task.FromResult(targetPath));
             var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetDefaultVideoStream())
-                .Returns(targetStream);
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>() { firstStream, targetStream });
-            input.Object.DefaultVideoStreamIndex = 1;
+            var input = GetMovie(1, targetStream, new List<MediaStream> { firstStream, targetStream } );
 
-            var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.True(actual.HasImage);
             Assert.Equal(targetPath, actual.Path);
@@ -93,7 +83,7 @@ namespace Jellyfin.Providers.Tests.MediaInfo
         }
 
         [Fact]
-        public async void GetImage_Extract_FallbackToFirstVideoStream()
+        public async void GetImage_InvalidDefaultSingleVideoStream_ReturnsFirstVideoStreamImage()
         {
             MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
             string targetPath = "path.jpg";
@@ -103,13 +93,10 @@ namespace Jellyfin.Providers.Tests.MediaInfo
                 .Returns(Task.FromResult(targetPath));
             var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>() { targetStream });
-            // default must be set, ensure a stream is still found if not pointed at a video
-            input.Object.DefaultVideoStreamIndex = 5;
+            // provide query results for default (empty) and all streams (populated)
+            var input = GetMovie(5, null, new List<MediaStream> { targetStream });
 
-            var actual = await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            var actual = await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
             Assert.NotNull(actual);
             Assert.True(actual.HasImage);
             Assert.Equal(targetPath, actual.Path);
@@ -117,10 +104,12 @@ namespace Jellyfin.Providers.Tests.MediaInfo
         }
 
         [Fact]
-        public async void GetImage_Time_Default()
+        public async void GetImage_NoTimeSpanSet_CallsEncoderWithDefaultTime()
         {
             MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
 
+            // use a callback to catch the actual value
+            // provides more information on failure than verifying a specific input was called on the mock
             TimeSpan? actualTimeSpan = null;
             var mediaEncoder = new Mock<IMediaEncoder>(MockBehavior.Strict);
             mediaEncoder.Setup(encoder => encoder.ExtractVideoImage(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<MediaSourceInfo>(), It.IsAny<MediaStream>(), It.IsAny<Video3DFormat?>(), It.IsAny<TimeSpan?>(), CancellationToken.None))
@@ -128,20 +117,16 @@ namespace Jellyfin.Providers.Tests.MediaInfo
                 .Returns(Task.FromResult("path"));
             var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>() { targetStream });
-            // default must be set
-            input.Object.DefaultVideoStreamIndex = 0;
+            var input = GetMovie(0, targetStream, new List<MediaStream> { targetStream });
 
             // not testing return, just verifying what gets requested for time span
-            await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
 
             Assert.Equal(TimeSpan.FromSeconds(10), actualTimeSpan);
         }
 
         [Fact]
-        public async void GetImage_Time_Calculated()
+        public async void GetImage_TimeSpanSet_CallsEncoderWithCalculatedTime()
         {
             MediaStream targetStream = new () { Type = MediaStreamType.Video, Index = 0 };
 
@@ -152,17 +137,40 @@ namespace Jellyfin.Providers.Tests.MediaInfo
                 .Returns(Task.FromResult("path"));
             var videoImageProvider = GetVideoImageProvider(mediaEncoder.Object);
 
-            var input = new Mock<Movie>();
-            input.Setup(movie => movie.GetMediaStreams())
-                .Returns(new List<MediaStream>() { targetStream });
-            // default must be set
-            input.Object.DefaultVideoStreamIndex = 0;
-            input.Object.RunTimeTicks = 5000;
+            var input = GetMovie(0, targetStream, new List<MediaStream> { targetStream });
+            input.RunTimeTicks = 5000;
 
             // not testing return, just verifying what gets requested for time span
-            await videoImageProvider.GetImage(input.Object, ImageType.Primary, CancellationToken.None);
+            await videoImageProvider.GetImage(input, ImageType.Primary, CancellationToken.None);
 
             Assert.Equal(TimeSpan.FromTicks(500), actualTimeSpan);
         }
+
+        private static VideoImageProvider GetVideoImageProvider(IMediaEncoder? mediaEncoder)
+        {
+            // strict to ensure this isn't accidentally used where a prepared mock is intended
+            mediaEncoder ??= new Mock<IMediaEncoder>(MockBehavior.Strict).Object;
+            return new VideoImageProvider(mediaEncoder, new NullLogger<VideoImageProvider>());
+        }
+
+        private static Movie GetMovie(int defaultVideoStreamIndex, MediaStream? defaultStream, List<MediaStream> mediaStreams)
+        {
+            // Mocking IMediaSourceManager GetMediaStreams instead of mocking Movie works, but has concurrency problems
+            // between this and EmbeddedImageProviderTests due to BaseItem.MediaSourceManager being static
+            var movie = new Mock<Movie>
+            {
+                Object =
+                {
+                    DefaultVideoStreamIndex = defaultVideoStreamIndex
+                }
+            };
+
+            movie.Setup(item => item.GetDefaultVideoStream())
+                .Returns(defaultStream!);
+            movie.Setup(item => item.GetMediaStreams())
+                .Returns(mediaStreams);
+
+            return movie.Object;
+        }
     }
 }