Use platform separators in the DirectoryService path tests

1 files changed, 64 insertions, 58 deletions

diff --git a/tests/Jellyfin.Controller.Tests/DirectoryServiceTests.cs b/tests/Jellyfin.Controller.Tests/DirectoryServiceTests.cs
index 338ee9c903..14ef604d34 100644
--- a/tests/Jellyfin.Controller.Tests/DirectoryServiceTests.cs
+++ b/tests/Jellyfin.Controller.Tests/DirectoryServiceTests.cs
@@ -1,4 +1,5 @@
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.IO;
@@ -9,29 +10,31 @@ namespace Jellyfin.Controller.Tests
 {
     public class DirectoryServiceTests
     {
-        private const string LowerCasePath = "/music/someartist";
-        private const string UpperCasePath = "/music/SOMEARTIST";
+        // Path.GetDirectoryName, which Invalidate uses to find the parent, normalizes the
+        // separators, so cache keys only match the parent it returns when they use the platform's.
+        private static readonly string _lowerCasePath = LocalPath("/music/someartist");
+        private static readonly string _upperCasePath = LocalPath("/music/SOMEARTIST");
 
         private static readonly FileSystemMetadata[] _lowerCaseFileSystemMetadata =
         {
             new()
             {
-                FullName = LowerCasePath + "/Artwork",
+                FullName = Path.Combine(_lowerCasePath, "Artwork"),
                 IsDirectory = true
             },
             new()
             {
-                FullName = LowerCasePath + "/Some Other Folder",
+                FullName = Path.Combine(_lowerCasePath, "Some Other Folder"),
                 IsDirectory = true
             },
             new()
             {
-                FullName = LowerCasePath + "/Song 2.mp3",
+                FullName = Path.Combine(_lowerCasePath, "Song 2.mp3"),
                 IsDirectory = false
             },
             new()
             {
-                FullName = LowerCasePath + "/Song 3.mp3",
+                FullName = Path.Combine(_lowerCasePath, "Song 3.mp3"),
                 IsDirectory = false
             }
         };
@@ -40,12 +43,12 @@ namespace Jellyfin.Controller.Tests
         {
             new()
             {
-                FullName = UpperCasePath + "/Lyrics",
+                FullName = Path.Combine(_upperCasePath, "Lyrics"),
                 IsDirectory = true
             },
             new()
             {
-                FullName = UpperCasePath + "/Song 1.mp3",
+                FullName = Path.Combine(_upperCasePath, "Song 1.mp3"),
                 IsDirectory = false
             }
         };
@@ -54,12 +57,12 @@ namespace Jellyfin.Controller.Tests
         public void GetFileSystemEntries_GivenPathsWithDifferentCasing_CachesAll()
         {
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == UpperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == LowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == _upperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == _lowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
             var directoryService = new DirectoryService(fileSystemMock.Object);
 
-            var upperCaseResult = directoryService.GetFileSystemEntries(UpperCasePath);
-            var lowerCaseResult = directoryService.GetFileSystemEntries(LowerCasePath);
+            var upperCaseResult = directoryService.GetFileSystemEntries(_upperCasePath);
+            var lowerCaseResult = directoryService.GetFileSystemEntries(_lowerCasePath);
 
             Assert.Equal(_upperCaseFileSystemMetadata, upperCaseResult);
             Assert.Equal(_lowerCaseFileSystemMetadata, lowerCaseResult);
@@ -69,12 +72,12 @@ namespace Jellyfin.Controller.Tests
         public void GetFiles_GivenPathsWithDifferentCasing_ReturnsCorrectFiles()
         {
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == UpperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == LowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == _upperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == _lowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
             var directoryService = new DirectoryService(fileSystemMock.Object);
 
-            var upperCaseResult = directoryService.GetFiles(UpperCasePath);
-            var lowerCaseResult = directoryService.GetFiles(LowerCasePath);
+            var upperCaseResult = directoryService.GetFiles(_upperCasePath);
+            var lowerCaseResult = directoryService.GetFiles(_lowerCasePath);
 
             Assert.Equal(_upperCaseFileSystemMetadata.Where(f => !f.IsDirectory), upperCaseResult);
             Assert.Equal(_lowerCaseFileSystemMetadata.Where(f => !f.IsDirectory), lowerCaseResult);
@@ -84,12 +87,12 @@ namespace Jellyfin.Controller.Tests
         public void GetDirectories_GivenPathsWithDifferentCasing_ReturnsCorrectDirectories()
         {
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == UpperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == LowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == _upperCasePath), false)).Returns(_upperCaseFileSystemMetadata);
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(It.Is<string>(x => x == _lowerCasePath), false)).Returns(_lowerCaseFileSystemMetadata);
             var directoryService = new DirectoryService(fileSystemMock.Object);
 
-            var upperCaseResult = directoryService.GetDirectories(UpperCasePath);
-            var lowerCaseResult = directoryService.GetDirectories(LowerCasePath);
+            var upperCaseResult = directoryService.GetDirectories(_upperCasePath);
+            var lowerCaseResult = directoryService.GetDirectories(_lowerCasePath);
 
             Assert.Equal(_upperCaseFileSystemMetadata.Where(f => f.IsDirectory), upperCaseResult);
             Assert.Equal(_lowerCaseFileSystemMetadata.Where(f => f.IsDirectory), lowerCaseResult);
@@ -254,15 +257,15 @@ namespace Jellyfin.Controller.Tests
         public void GetFileSystemEntries_RepeatedPath_ReadsTheFileSystemOnce()
         {
             var fileSystemMock = new Mock<IFileSystem>(MockBehavior.Strict);
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(LowerCasePath))
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(_lowerCasePath))
                 .Returns(_lowerCaseFileSystemMetadata);
 
             var directoryService = new DirectoryService(fileSystemMock.Object);
 
-            directoryService.GetFileSystemEntries(LowerCasePath);
-            directoryService.GetFileSystemEntries(LowerCasePath);
+            directoryService.GetFileSystemEntries(_lowerCasePath);
+            directoryService.GetFileSystemEntries(_lowerCasePath);
 
-            fileSystemMock.Verify(f => f.GetFileSystemEntries(LowerCasePath), Times.Once);
+            fileSystemMock.Verify(f => f.GetFileSystemEntries(_lowerCasePath), Times.Once);
         }
 
         [Fact]
@@ -294,28 +297,28 @@ namespace Jellyfin.Controller.Tests
         public void GetFileSystemEntries_SecondServiceOverSameFileSystem_ReusesTheFirstAnswer()
         {
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(LowerCasePath))
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(_lowerCasePath))
                 .Returns(_lowerCaseFileSystemMetadata);
 
-            new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(LowerCasePath);
-            var result = new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(LowerCasePath);
+            new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(_lowerCasePath);
+            var result = new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(_lowerCasePath);
 
             Assert.Equal(_lowerCaseFileSystemMetadata, result);
-            fileSystemMock.Verify(f => f.GetFileSystemEntries(LowerCasePath), Times.Once);
+            fileSystemMock.Verify(f => f.GetFileSystemEntries(_lowerCasePath), Times.Once);
         }
 
         [Fact]
         public void GetFileSystemEntries_SeparateFileSystems_DoNotShareAnswers()
         {
             var firstFileSystem = new Mock<IFileSystem>();
-            firstFileSystem.Setup(f => f.GetFileSystemEntries(LowerCasePath))
+            firstFileSystem.Setup(f => f.GetFileSystemEntries(_lowerCasePath))
                 .Returns(_lowerCaseFileSystemMetadata);
             var secondFileSystem = new Mock<IFileSystem>();
-            secondFileSystem.Setup(f => f.GetFileSystemEntries(LowerCasePath))
+            secondFileSystem.Setup(f => f.GetFileSystemEntries(_lowerCasePath))
                 .Returns(_upperCaseFileSystemMetadata);
 
-            var firstResult = new DirectoryService(firstFileSystem.Object).GetFileSystemEntries(LowerCasePath);
-            var secondResult = new DirectoryService(secondFileSystem.Object).GetFileSystemEntries(LowerCasePath);
+            var firstResult = new DirectoryService(firstFileSystem.Object).GetFileSystemEntries(_lowerCasePath);
+            var secondResult = new DirectoryService(secondFileSystem.Object).GetFileSystemEntries(_lowerCasePath);
 
             Assert.Equal(_lowerCaseFileSystemMetadata, firstResult);
             Assert.Equal(_upperCaseFileSystemMetadata, secondResult);
@@ -325,53 +328,53 @@ namespace Jellyfin.Controller.Tests
         public void Invalidate_GivenADirectory_DropsBothTheListingAndTheFilePaths()
         {
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.SetupSequence(f => f.GetFileSystemEntries(LowerCasePath))
+            fileSystemMock.SetupSequence(f => f.GetFileSystemEntries(_lowerCasePath))
                 .Returns(_lowerCaseFileSystemMetadata)
                 .Returns(_upperCaseFileSystemMetadata);
-            fileSystemMock.SetupSequence(f => f.GetFilePaths(LowerCasePath, false))
-                .Returns(new[] { LowerCasePath + "/Song 2.mp3" })
-                .Returns(new[] { LowerCasePath + "/Song 2.mp3", LowerCasePath + "/Song 2.srt" });
+            fileSystemMock.SetupSequence(f => f.GetFilePaths(_lowerCasePath, false))
+                .Returns(new[] { Path.Combine(_lowerCasePath, "Song 2.mp3") })
+                .Returns(new[] { Path.Combine(_lowerCasePath, "Song 2.mp3"), Path.Combine(_lowerCasePath, "Song 2.srt") });
 
             var directoryService = new DirectoryService(fileSystemMock.Object);
-            directoryService.GetFileSystemEntries(LowerCasePath);
-            directoryService.GetFilePaths(LowerCasePath);
+            directoryService.GetFileSystemEntries(_lowerCasePath);
+            directoryService.GetFilePaths(_lowerCasePath);
 
-            directoryService.Invalidate(LowerCasePath);
+            directoryService.Invalidate(_lowerCasePath);
 
-            Assert.Equal(_upperCaseFileSystemMetadata, directoryService.GetFileSystemEntries(LowerCasePath));
-            Assert.Equal(2, directoryService.GetFilePaths(LowerCasePath).Count);
+            Assert.Equal(_upperCaseFileSystemMetadata, directoryService.GetFileSystemEntries(_lowerCasePath));
+            Assert.Equal(2, directoryService.GetFilePaths(_lowerCasePath).Count);
         }
 
         [Fact]
         public void Invalidate_GivenAFile_DropsTheListingOfTheDirectoryHoldingIt()
         {
-            const string NewFile = LowerCasePath + "/Song 2.srt";
+            var newFile = Path.Combine(_lowerCasePath, "Song 2.srt");
 
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.SetupSequence(f => f.GetFileSystemEntries(LowerCasePath))
+            fileSystemMock.SetupSequence(f => f.GetFileSystemEntries(_lowerCasePath))
                 .Returns(_lowerCaseFileSystemMetadata)
                 .Returns(_upperCaseFileSystemMetadata);
 
             var directoryService = new DirectoryService(fileSystemMock.Object);
-            directoryService.GetFileSystemEntries(LowerCasePath);
+            directoryService.GetFileSystemEntries(_lowerCasePath);
 
-            directoryService.Invalidate(NewFile);
+            directoryService.Invalidate(newFile);
 
-            Assert.Equal(_upperCaseFileSystemMetadata, directoryService.GetFileSystemEntries(LowerCasePath));
+            Assert.Equal(_upperCaseFileSystemMetadata, directoryService.GetFileSystemEntries(_lowerCasePath));
         }
 
         [Fact]
         public void Invalidate_OnOneService_IsSeenByAnotherOverTheSameFileSystem()
         {
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.SetupSequence(f => f.GetFileSystemEntries(LowerCasePath))
+            fileSystemMock.SetupSequence(f => f.GetFileSystemEntries(_lowerCasePath))
                 .Returns(_lowerCaseFileSystemMetadata)
                 .Returns(_upperCaseFileSystemMetadata);
 
-            new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(LowerCasePath);
-            new DirectoryService(fileSystemMock.Object).Invalidate(LowerCasePath + "/Song 2.srt");
+            new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(_lowerCasePath);
+            new DirectoryService(fileSystemMock.Object).Invalidate(Path.Combine(_lowerCasePath, "Song 2.srt"));
 
-            var result = new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(LowerCasePath);
+            var result = new DirectoryService(fileSystemMock.Object).GetFileSystemEntries(_lowerCasePath);
 
             Assert.Equal(_upperCaseFileSystemMetadata, result);
         }
@@ -379,21 +382,21 @@ namespace Jellyfin.Controller.Tests
         [Fact]
         public void GetFilePaths_ClearingTheCache_KeepsTheParentDirectory()
         {
-            const string ParentPath = "/music";
+            var parentPath = LocalPath("/music");
 
             var fileSystemMock = new Mock<IFileSystem>();
-            fileSystemMock.Setup(f => f.GetFilePaths(LowerCasePath))
-                .Returns(new[] { LowerCasePath + "/Song 2.mp3" });
-            fileSystemMock.Setup(f => f.GetFileSystemEntries(ParentPath))
+            fileSystemMock.Setup(f => f.GetFilePaths(_lowerCasePath))
+                .Returns(new[] { Path.Combine(_lowerCasePath, "Song 2.mp3") });
+            fileSystemMock.Setup(f => f.GetFileSystemEntries(parentPath))
                 .Returns(_lowerCaseFileSystemMetadata);
 
             var directoryService = new DirectoryService(fileSystemMock.Object);
-            directoryService.GetFileSystemEntries(ParentPath);
+            directoryService.GetFileSystemEntries(parentPath);
 
-            directoryService.GetFilePaths(LowerCasePath, true);
+            directoryService.GetFilePaths(_lowerCasePath, true);
 
-            directoryService.GetFileSystemEntries(ParentPath);
-            fileSystemMock.Verify(f => f.GetFileSystemEntries(ParentPath), Times.Once);
+            directoryService.GetFileSystemEntries(parentPath);
+            fileSystemMock.Verify(f => f.GetFileSystemEntries(parentPath), Times.Once);
         }
 
         [Fact]
@@ -412,5 +415,8 @@ namespace Jellyfin.Controller.Tests
 
             Assert.NotNull(directoryService.GetFileSystemEntry(MissingPath));
         }
+
+        private static string LocalPath(string path)
+            => path.Replace('/', Path.DirectorySeparatorChar);
     }
 }