Merge branch 'backend-refactor-rev' into audit-merge-three

Adapt the refactored web player to the new backend API (id path params,
bulk track adds, flat list items, mix kind) and port AddAlbumToPlayList
to the backend conventions.

backend/Tests/Musify.Application.Tests/Albums/AddTracksToAlbumCommandHandlerTests.cs

@@ -7,9 +7,9 @@ using Xunit;
 
 namespace Musify.Application.Tests.Albums
 {
-    public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
+    public sealed class AddTracksToAlbumCommandHandlerTests : HandlerTestBase
     {
-        private AddTrackToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToAlbumCommandHandler>());
+        private AddTracksToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToAlbumCommandHandler>());
 
         [Fact]
         public async Task Handle_FirstTrack_AddsItAtNumberOne()
@@ -19,7 +19,7 @@ namespace Musify.Application.Tests.Albums
             var track = TestEntities.Track(owner);
             await SeedAsync(owner, album, track);
 
-            var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             var link = Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
@@ -33,13 +33,13 @@ namespace Musify.Application.Tests.Albums
             var track = TestEntities.Track(owner);
             await SeedAsync(owner, track);
 
-            var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, Guid.NewGuid(), track.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, Guid.NewGuid(), [track.Id]), TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -47,9 +47,9 @@ namespace Musify.Application.Tests.Albums
             var track = TestEntities.Track(owner);
             await SeedAsync(owner, stranger, album, track);
 
-            var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(stranger.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(stranger.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]
@@ -59,13 +59,13 @@ namespace Musify.Application.Tests.Albums
             var album = TestEntities.Album(owner.Id);
             await SeedAsync(owner, album);
 
-            var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
 
         [Fact]
-        public async Task Handle_TrackOwnedByAnotherUser_ReturnsUnauthorized()
+        public async Task Handle_TrackOwnedByAnotherUser_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var otherOwner = TestEntities.User(2, "other");
@@ -73,13 +73,13 @@ namespace Musify.Application.Tests.Albums
             var foreignTrack = TestEntities.Track(otherOwner);
             await SeedAsync(owner, otherOwner, album, foreignTrack);
 
-            var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, foreignTrack.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [foreignTrack.Id]), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]
-        public async Task Handle_AlreadyInAlbum_ReturnsConflict()
+        public async Task Handle_AlreadyInAlbum_IsSkipped()
         {
             var owner = TestEntities.User();
             var album = TestEntities.Album(owner.Id);
@@ -87,9 +87,10 @@ namespace Musify.Application.Tests.Albums
             var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
             await SeedAsync(owner, album, track, link);
 
-            var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+            Assert.False(result.IsError);
+            Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
         }
 
         [Fact]
@@ -102,7 +103,7 @@ namespace Musify.Application.Tests.Albums
             var existingLink = new AlbumHasTrack { AlbumId = album.Id, TrackId = firstTrack.Id, TrackNumber = 3 };
             await SeedAsync(owner, album, firstTrack, secondTrack, existingLink);
 
-            var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, secondTrack.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [secondTrack.Id]), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             var newLink = await Database.AlbumHasTracks.SingleAsync(l => l.TrackId == secondTrack.Id, TestContext.Current.CancellationToken);

backend/Tests/Musify.Application.Tests/Albums/CreateAlbumCommandHandlerTests.cs

@@ -16,11 +16,9 @@ namespace Musify.Application.Tests.Albums
         private CreateAlbumCommandHandler CreateHandler() => new(
             eventBus,
             Database,
-            new UploadIntentValidator(Database, storageService),
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
             NoOpLogger<CreateAlbumCommandHandler>(),
-            TestConfigurations.Storage(),
-            TestConfigurations.Album(),
-            TestConfigurations.UploadIntent());
+            TestConfigurations.Album());
 
         [Fact]
         public async Task Handle_ValidPictureIntent_CreatesAlbumAndPublishesResourcesEvent()

backend/Tests/Musify.Application.Tests/Albums/DeleteAlbumCommandHandlerTests.cs

@@ -1,16 +1,21 @@
 using ErrorOr;
 using Musify.Application.Albums;
+using Musify.Application.Contracts;
 using Musify.Application.Tests.TestSupport;
+using Musify.Domain.ValueObjects;
+using NSubstitute;
 using Xunit;
 
 namespace Musify.Application.Tests.Albums
 {
     public sealed class DeleteAlbumCommandHandlerTests : HandlerTestBase
     {
-        private DeleteAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<DeleteAlbumCommandHandler>());
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+
+        private DeleteAlbumCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeleteAlbumCommandHandler>());
 
         [Fact]
-        public async Task Handle_Owner_RemovesAlbum()
+        public async Task Handle_Owner_MarksAlbumAsRemoving()
         {
             var owner = TestEntities.User();
             var album = TestEntities.Album(owner.Id);
@@ -19,7 +24,10 @@ namespace Musify.Application.Tests.Albums
             var result = await CreateHandler().Handle(new DeleteAlbumCommand(owner.Id, album.Id), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
-            Assert.Null(await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken));
+            var stored = await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.DeleteAlbumEvent>(), Arg.Any<CancellationToken>());
         }
 
         [Fact]
@@ -31,7 +39,7 @@ namespace Musify.Application.Tests.Albums
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorizedAndKeepsAlbum()
+        public async Task Handle_NotOwner_ReturnsForbiddenAndKeepsAlbum()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -40,7 +48,7 @@ namespace Musify.Application.Tests.Albums
 
             var result = await CreateHandler().Handle(new DeleteAlbumCommand(stranger.Id, album.Id), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
             Assert.NotNull(await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken));
         }
     }

backend/Tests/Musify.Application.Tests/Albums/GetAlbumCoverQueryHandlerTests.cs

@@ -1,38 +0,0 @@
-using ErrorOr;
-using Musify.Application.Albums;
-using Musify.Application.Tests.TestSupport;
-using Xunit;
-
-namespace Musify.Application.Tests.Albums
-{
-    public sealed class GetAlbumCoverQueryHandlerTests : HandlerTestBase
-    {
-        private GetAlbumCoverQueryHandler CreateHandler() =>
-            new(Database, TestConfigurations.Storage("covers-bucket"), TestConfigurations.Album());
-
-        [Theory]
-        [InlineData("small", "small.webp")]
-        [InlineData("large", "large.webp")]
-        [InlineData("medium", "medium.webp")]
-        public async Task Handle_ExistingAlbum_ReturnsRequestedSize(string size, string expectedFileName)
-        {
-            var owner = TestEntities.User();
-            var album = TestEntities.Album(owner.Id);
-            await SeedAsync(owner, album);
-
-            var result = await CreateHandler().Handle(new GetAlbumCoverQuery(album.Id, size), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal("covers-bucket", result.Value.Bucket);
-            Assert.EndsWith(expectedFileName, result.Value.Key);
-        }
-
-        [Fact]
-        public async Task Handle_AlbumMissing_ReturnsNotFound()
-        {
-            var result = await CreateHandler().Handle(new GetAlbumCoverQuery(Guid.NewGuid(), "small"), TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-        }
-    }
-}

backend/Tests/Musify.Application.Tests/Albums/GetAlbumsQueryHandlerTests.cs

@@ -15,10 +15,8 @@ namespace Musify.Application.Tests.Albums
             await SeedAsync(owner, TestEntities.Album(owner.Id, "Alpha"), TestEntities.Album(owner.Id, "Beta"));
 
             var result = await CreateHandler().Handle(new GetAlbumsQuery(Title: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(2, result.Value.TotalItemCount);
-            Assert.All(result.Value.Items, item => Assert.NotNull(item.Album));
+            Assert.Equal(2, result.TotalItemCount);
+            Assert.All(result.Items, item => Assert.NotNull(item));
         }
 
         [Fact]
@@ -28,10 +26,8 @@ namespace Musify.Application.Tests.Albums
             await SeedAsync(owner, TestEntities.Album(owner.Id, "Rock Classics"), TestEntities.Album(owner.Id, "Jazz Favorites"));
 
             var result = await CreateHandler().Handle(new GetAlbumsQuery(Title: "rock", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            var item = Assert.Single(result.Value.Items);
-            Assert.Equal("Rock Classics", item.Album.Title);
+            var item = Assert.Single(result.Items);
+            Assert.Equal("Rock Classics", item.Title);
         }
 
         [Fact]
@@ -41,10 +37,8 @@ namespace Musify.Application.Tests.Albums
             await SeedAsync(owner, TestEntities.Album(owner.Id, "One"), TestEntities.Album(owner.Id, "Two"), TestEntities.Album(owner.Id, "Three"));
 
             var result = await CreateHandler().Handle(new GetAlbumsQuery(Title: null, PageNumber: 1, PageSize: 2), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(2, result.Value.Items.Count);
-            Assert.True(result.Value.HasNextPage);
+            Assert.Equal(2, result.Items.Count);
+            Assert.True(result.HasNextPage);
         }
     }
 }

backend/Tests/Musify.Application.Tests/Albums/GetRecentlyListenedAlbumsQueryHandlerTests.cs

@@ -25,9 +25,7 @@ namespace Musify.Application.Tests.Albums
                 TestEntities.ListeningHistory(owner.Id, newerTrack.Id, DateTime.UtcNow.AddDays(-1)));
 
             var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(["Newer", "Older"], result.Value.Select(album => album.Title));
+            Assert.Equal(["Newer", "Older"], result.Select(album => album.Title));
         }
 
         [Fact]
@@ -37,9 +35,7 @@ namespace Musify.Application.Tests.Albums
             await SeedAsync(owner);
 
             var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Empty(result.Value);
+            Assert.Empty(result);
         }
 
         [Fact]
@@ -53,9 +49,7 @@ namespace Musify.Application.Tests.Albums
             await SeedAsync([owner, .. albums, .. tracks, .. links, .. histories]);
 
             var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 2), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(2, result.Value.Count);
+            Assert.Equal(2, result.Count);
         }
 
         [Fact]
@@ -75,7 +69,7 @@ namespace Musify.Application.Tests.Albums
 
             var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
 
-            Assert.Equal(["Counted album"], result.Value.Select(album => album.Title));
+            Assert.Equal(["Counted album"], result.Select(album => album.Title));
         }
     }
 }

backend/Tests/Musify.Application.Tests/Albums/RemoveTrackFromAlbumCommandHandlerTests.cs

@@ -46,7 +46,7 @@ namespace Musify.Application.Tests.Albums
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -55,7 +55,7 @@ namespace Musify.Application.Tests.Albums
 
             var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(stranger.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/Albums/RequestAlbumPictureUploadCommandHandlerTests.cs

@@ -17,17 +17,20 @@ namespace Musify.Application.Tests.Albums
         private RequestAlbumPictureUploadCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
         {
             storageService
-                .GetUploadUrlAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TimeSpan>(), Arg.Any<CancellationToken>())
+                .GetUploadUrlAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TimeSpan>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
                 .Returns("https://storage.musify.test/presigned-upload");
 
+            var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
+
             return new RequestAlbumPictureUploadCommandHandler(
-                Database,
-                new UploadIntentValidator(Database, storageService),
-                storageService,
-                NoOpLogger<RequestAlbumPictureUploadCommandHandler>(),
-                TestConfigurations.Storage(),
-                TestConfigurations.Album(),
-                uploadIntentConfig ?? TestConfigurations.UploadIntent());
+                new UploadIntentIssuer(
+                    Database,
+                    storageService,
+                    new UploadIntentValidator(Database, storageService, config),
+                    TestConfigurations.Storage(),
+                    config,
+                    NoOpLogger<UploadIntentIssuer>()),
+                TestConfigurations.Album());
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/Albums/UpdateAlbumCommandHandlerTests.cs

@@ -16,11 +16,9 @@ namespace Musify.Application.Tests.Albums
         private UpdateAlbumCommandHandler CreateHandler() => new(
             eventBus,
             Database,
-            new UploadIntentValidator(Database, storageService),
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
             NoOpLogger<UpdateAlbumCommandHandler>(),
-            TestConfigurations.Storage(),
-            TestConfigurations.Album(),
-            TestConfigurations.UploadIntent());
+            TestConfigurations.Album());
 
         [Fact]
         public async Task Handle_Owner_UpdatesTitleDescriptionAndReleaseYear()
@@ -77,7 +75,7 @@ namespace Musify.Application.Tests.Albums
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -88,7 +86,7 @@ namespace Musify.Application.Tests.Albums
 
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
     }
 }

backend/Tests/Musify.Application.Tests/Application.Tests.csproj

@@ -27,6 +27,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\Core\Musify.Domain\Domain.csproj" />
     <ProjectReference Include="..\..\Core\Musify.Application\Application.csproj" />
+    <ProjectReference Include="..\..\Core\Musify.Infrastructure\Infrastructure.csproj" />
   </ItemGroup>
 
 </Project>

backend/Tests/Musify.Application.Tests/Configuration/PicturesConfigurationTests.cs

@@ -0,0 +1,51 @@
+using Musify.Application.Configuration;
+using Xunit;
+
+namespace Musify.Application.Tests.Configuration
+{
+    public sealed class PicturesConfigurationTests
+    {
+        [Fact]
+        public void AlbumRoutes_BuildTheSameKeysAsBefore()
+        {
+            var routes = new AlbumConfiguration().Routes;
+
+            Assert.Equal("Albums/SmallPictures/a.webp", routes.BuildPicturePath(PictureSize.Small, "a.webp"));
+            Assert.Equal("Albums/MediumPictures/a.webp", routes.BuildPicturePath(PictureSize.Medium, "a.webp"));
+            Assert.Equal("Albums/LargePictures/a.webp", routes.BuildPicturePath(PictureSize.Large, "a.webp"));
+            Assert.Equal("uploads/7/Albums/OriginalPictures/a.webp", routes.BuildOriginalPicturePath(7, "a.webp"));
+            Assert.Equal("temp/7/Albums/obj.webp", routes.BuildTempPath("temp", 7, "obj.webp"));
+        }
+
+        [Fact]
+        public void TrackRoutes_KeepTheTrackFolderLayout()
+        {
+            var routes = new TrackConfiguration().Routes;
+
+            Assert.Equal("Tracks/ProcessedAudios/folder", routes.BuildProcessedAudioPath("folder"));
+            Assert.Equal("uploads/7/Tracks/OriginalAudios/song.mp3", routes.BuildOriginalAudioPath(7, "song.mp3"));
+            Assert.Equal("Tracks/PresetSmallPicture.webp", routes.PresetSmallPicturePath);
+        }
+
+        [Fact]
+        public void ToImageSizes_UsesTheRoutesFolders()
+        {
+            var configuration = new PlayListConfiguration();
+
+            var sizes = configuration.PicturesSizes.ToImageSizes(configuration.Routes);
+
+            Assert.Equal("PlayLists/SmallPictures", sizes.Small.SavePath);
+            Assert.Equal(128, sizes.Small.Width);
+            Assert.Equal(512, sizes.Large.Width);
+        }
+
+        [Theory]
+        [InlineData("small", PictureSize.Small)]
+        [InlineData("LARGE", PictureSize.Large)]
+        [InlineData("medium", PictureSize.Medium)]
+        [InlineData("whatever", PictureSize.Medium)]
+        [InlineData(null, PictureSize.Medium)]
+        public void PictureSizeParser_DefaultsToMedium(string? value, PictureSize expected) =>
+            Assert.Equal(expected, PictureSizeParser.Parse(value));
+    }
+}

backend/Tests/Musify.Application.Tests/Genres/GetAvailableGenresQueryHandlerTests.cs

@@ -1,4 +1,5 @@
 using Musify.Application.Genres;
+using Musify.Application.Genres.Responses;
 using Musify.Domain.ValueObjects;
 using Xunit;
 

backend/Tests/Musify.Application.Tests/Genres/GetGenresQueryHandlerTests.cs

@@ -1,6 +1,5 @@
 using Musify.Application.Genres;
 using Musify.Application.Tests.TestSupport;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
@@ -26,10 +25,7 @@ namespace Musify.Application.Tests.Genres
             var rockB = TestEntities.Track(owner, "Rock B", tags: [Genre.Rock, Genre.Indie]);
             var jazz = TestEntities.Track(owner, "Jazz", tags: [Genre.Jazz]);
             await SeedAsync(
-                owner, rockA, rockB, jazz,
-                new UserHasTrack { UserId = owner.Id, TrackId = rockA.Id },
-                new UserHasTrack { UserId = owner.Id, TrackId = rockB.Id },
-                new UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
+                owner, rockA, rockB, jazz);
 
             var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
 
@@ -38,32 +34,5 @@ namespace Musify.Application.Tests.Genres
                 result.Select(r => (r.Genre, r.TrackCount)));
         }
 
-        [Fact]
-        public async Task Handle_TrackInSeveralLibraries_IsCountedOnce()
-        {
-            var owner = TestEntities.User();
-            var other = TestEntities.User(id: 2, name: "other-user");
-            var track = TestEntities.Track(owner, tags: [Genre.Pop]);
-            await SeedAsync(
-                owner, other, track,
-                new UserHasTrack { UserId = owner.Id, TrackId = track.Id },
-                new UserHasTrack { UserId = other.Id, TrackId = track.Id });
-
-            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
-
-            Assert.Equal(1, Assert.Single(result).TrackCount);
-        }
-
-        [Fact]
-        public async Task Handle_TrackNotInAnyLibrary_IsIgnored()
-        {
-            var owner = TestEntities.User();
-            var track = TestEntities.Track(owner, tags: [Genre.Metal]);
-            await SeedAsync(owner, track);
-
-            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
-
-            Assert.Empty(result);
-        }
     }
 }

backend/Tests/Musify.Application.Tests/Likes/GetLikedTracksQueryHandlerTests.cs

@@ -21,9 +21,7 @@ namespace Musify.Application.Tests.Likes
                 new TrackLike { UserId = owner.Id, TrackId = newer.Id, CreatedAt = DateTime.UtcNow });
 
             var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(["Newer like", "Older like"], result.Value.Items.Select(track => track.Title));
+            Assert.Equal(["Newer like", "Older like"], result.Items.Select(track => track.Title));
         }
 
         [Fact]
@@ -33,9 +31,7 @@ namespace Musify.Application.Tests.Likes
             await SeedAsync(owner);
 
             var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Empty(result.Value.Items);
+            Assert.Empty(result.Items);
         }
 
         [Fact]
@@ -47,9 +43,7 @@ namespace Musify.Application.Tests.Likes
             await SeedAsync(owner, stranger, track, new TrackLike { UserId = stranger.Id, TrackId = track.Id });
 
             var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Empty(result.Value.Items);
+            Assert.Empty(result.Items);
         }
     }
 }

backend/Tests/Musify.Application.Tests/Mixes/GenerateMixesForUserCommandHandlerTests.cs

@@ -1,7 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Mixes;
 using Musify.Application.Tests.TestSupport;
-using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.Mixes
@@ -17,9 +17,7 @@ namespace Musify.Application.Tests.Mixes
             var user = TestEntities.User();
             await SeedAsync(user);
 
-            var result = await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
             Assert.Empty(await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken));
         }
 
@@ -30,15 +28,12 @@ namespace Musify.Application.Tests.Mixes
             var track = TestEntities.Track(user);
             await SeedAsync(
                 user, track,
-                new UserHasTrack { UserId = user.Id, TrackId = track.Id },
                 TestEntities.ListeningHistory(user.Id, track.Id));
 
-            var result = await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
             var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
             Assert.Single(mixes);
-            Assert.Equal("Tu mezcla diaria", mixes[0].Title);
+            Assert.Equal(MixKind.Daily, mixes[0].Kind);
         }
 
         [Fact]
@@ -48,25 +43,21 @@ namespace Musify.Application.Tests.Mixes
             var listenedTrack = TestEntities.Track(user, "Listened Track");
             var unheardTrack = TestEntities.Track(user, "Unheard Track");
 
-            var staleMix = TestEntities.Mix(user.Id, "Stale Mix");
+            var staleMix = TestEntities.Mix(user.Id, MixKind.Daily);
             var staleItem = TestEntities.MixItem(staleMix.Id, listenedTrack.Id);
 
             await SeedAsync(
                 user, listenedTrack, unheardTrack, staleMix, staleItem,
-                new UserHasTrack { UserId = user.Id, TrackId = listenedTrack.Id },
-                new UserHasTrack { UserId = user.Id, TrackId = unheardTrack.Id },
                 TestEntities.ListeningHistory(user.Id, listenedTrack.Id));
 
-            var result = await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
             var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
-            Assert.DoesNotContain(mixes, mix => mix.Title == "Stale Mix");
-            Assert.Contains(mixes, mix => mix.Title == "Descubrimiento");
-            Assert.Contains(mixes, mix => mix.Title == "Tu mezcla diaria");
+            Assert.DoesNotContain(mixes, mix => mix.Id == staleMix.Id);
+            Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
+            Assert.Contains(mixes, mix => mix.Kind == MixKind.Daily);
             Assert.Empty(await Database.MixItems.Where(item => item.MixId == staleMix.Id).ToListAsync(TestContext.Current.CancellationToken));
 
-            var discoveryMix = mixes.Single(mix => mix.Title == "Descubrimiento");
+            var discoveryMix = mixes.Single(mix => mix.Kind == MixKind.Discovery);
             var discoveryItems = await Database.MixItems
                 .Where(item => item.MixId == discoveryMix.Id)
                 .ToListAsync(TestContext.Current.CancellationToken);
@@ -80,13 +71,12 @@ namespace Musify.Application.Tests.Mixes
             var skipped = TestEntities.Track(user, "Only skipped");
             await SeedAsync(
                 user, skipped,
-                new UserHasTrack { UserId = user.Id, TrackId = skipped.Id },
                 TestEntities.ListeningHistory(user.Id, skipped.Id, playedSeconds: 3, isCounted: false));
 
             await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
 
             var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
-            Assert.Contains(mixes, mix => mix.Title == "Descubrimiento");
+            Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
         }
     }
 }

backend/Tests/Musify.Application.Tests/Mixes/GetMixByIdQueryHandlerTests.cs

@@ -1,6 +1,7 @@
 using ErrorOr;
 using Musify.Application.Mixes;
 using Musify.Application.Tests.TestSupport;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.Mixes
@@ -15,7 +16,7 @@ namespace Musify.Application.Tests.Mixes
             var owner = TestEntities.User();
             var firstTrack = TestEntities.Track(owner, "First");
             var secondTrack = TestEntities.Track(owner, "Second");
-            var mix = TestEntities.Mix(owner.Id, "Discovery");
+            var mix = TestEntities.Mix(owner.Id, MixKind.Daily);
             var second = TestEntities.MixItem(mix.Id, secondTrack.Id, position: 1);
             var first = TestEntities.MixItem(mix.Id, firstTrack.Id, position: 0);
             await SeedAsync(owner, firstTrack, secondTrack, mix, second, first);
@@ -23,7 +24,7 @@ namespace Musify.Application.Tests.Mixes
             var result = await CreateHandler().Handle(new GetMixByIdQuery(owner.Id, mix.Id), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
-            Assert.Equal("Discovery", result.Value.Title);
+            Assert.Equal(MixKind.Daily, result.Value.Kind);
             Assert.Equal(["First", "Second"], result.Value.Items.Select(item => item.Title));
         }
 

backend/Tests/Musify.Application.Tests/Mixes/GetMixesByUserIdQueryHandlerTests.cs

@@ -1,5 +1,6 @@
 using Musify.Application.Mixes;
 using Musify.Application.Tests.TestSupport;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.Mixes
@@ -13,15 +14,13 @@ namespace Musify.Application.Tests.Mixes
         {
             var owner = TestEntities.User(1, "owner");
             var other = TestEntities.User(2, "other");
-            var second = TestEntities.Mix(owner.Id, "Second", position: 1);
-            var first = TestEntities.Mix(owner.Id, "First", position: 0);
-            var theirs = TestEntities.Mix(other.Id, "Theirs");
+            var second = TestEntities.Mix(owner.Id, MixKind.Daily, position: 1);
+            var first = TestEntities.Mix(owner.Id, MixKind.Discovery, position: 0);
+            var theirs = TestEntities.Mix(other.Id);
             await SeedAsync(owner, other, second, first, theirs);
 
             var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(["First", "Second"], result.Value.Select(mix => mix.Title));
+            Assert.Equal([MixKind.Discovery, MixKind.Daily], result.Select(mix => mix.Kind));
         }
 
         [Fact]
@@ -31,9 +30,7 @@ namespace Musify.Application.Tests.Mixes
             await SeedAsync(owner);
 
             var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Empty(result.Value);
+            Assert.Empty(result);
         }
     }
 }

backend/Tests/Musify.Application.Tests/Pictures/GetCoverQueryHandlerTests.cs

@@ -0,0 +1,105 @@
+using ErrorOr;
+using Musify.Application.Configuration;
+using Musify.Application.Pictures;
+using Musify.Application.Tests.TestSupport;
+using Musify.Domain.ValueObjects;
+using Xunit;
+
+namespace Musify.Application.Tests.Pictures
+{
+    public sealed class GetCoverQueryHandlerTests : HandlerTestBase
+    {
+        private GetCoverQueryHandler CreateHandler() => new(
+            Database,
+            TestConfigurations.Storage("covers-bucket"),
+            TestConfigurations.Track(),
+            TestConfigurations.Album(),
+            TestConfigurations.PlayList());
+
+        [Theory]
+        [InlineData(PictureSize.Small, "small.webp")]
+        [InlineData(PictureSize.Medium, "medium.webp")]
+        [InlineData(PictureSize.Large, "large.webp")]
+        public async Task Handle_ProcessedTrack_ReturnsRequestedSize(PictureSize size, string expectedFileName)
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
+
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Track, track.Id, size), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal("covers-bucket", result.Value.Bucket);
+            Assert.EndsWith(expectedFileName, result.Value.Key);
+            Assert.Equal("image/webp", result.Value.ContentType);
+        }
+
+        [Theory]
+        [InlineData(PictureSize.Small, "small.webp")]
+        [InlineData(PictureSize.Medium, "medium.webp")]
+        [InlineData(PictureSize.Large, "large.webp")]
+        public async Task Handle_ProcessedAlbum_ReturnsRequestedSize(PictureSize size, string expectedFileName)
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, album);
+
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id, size), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.EndsWith(expectedFileName, result.Value.Key);
+        }
+
+        [Fact]
+        public async Task Handle_ProcessedPlayList_ReturnsRequestedSize()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.PlayList, playList.Id, PictureSize.Large), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.EndsWith("large.webp", result.Value.Key);
+        }
+
+        [Theory]
+        [InlineData(CoverOwner.Track)]
+        [InlineData(CoverOwner.Album)]
+        [InlineData(CoverOwner.PlayList)]
+        public async Task Handle_EntityMissing_ReturnsNotFound(CoverOwner owner)
+        {
+            var result = await CreateHandler().Handle(new GetCoverQuery(owner, Guid.NewGuid()), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_AlbumPicturesStillProcessing_FallsBackToTheOriginal()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id, pictures: EntityPictures.Pending("original.png"));
+            await SeedAsync(owner, album);
+
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id, PictureSize.Small), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Contains($"{owner.Id}", result.Value.Key);
+            Assert.EndsWith("original.png", result.Value.Key);
+            Assert.Equal("image/png", result.Value.ContentType);
+        }
+
+        [Fact]
+        public async Task Handle_RemovingAlbum_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            album.LifeCycleStatus = LifeCycleStatus.Removing;
+            await SeedAsync(owner, album);
+
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/PlayLists/AddAlbumToPlayListCommandHandlerTests.cs

@@ -63,7 +63,7 @@ namespace Musify.Application.Tests.PlayLists
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -73,7 +73,7 @@ namespace Musify.Application.Tests.PlayLists
 
             var result = await CreateHandler().Handle(new AddAlbumToPlayListCommand(stranger.Id, playList.Id, album.Id), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/PlayLists/AddTracksToPlayListCommandHandlerTests.cs

@@ -7,9 +7,9 @@ using Xunit;
 
 namespace Musify.Application.Tests.PlayLists
 {
-    public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
+    public sealed class AddTracksToPlayListCommandHandlerTests : HandlerTestBase
     {
-        private AddTrackToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToPlayListCommandHandler>());
+        private AddTracksToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToPlayListCommandHandler>());
 
         [Fact]
         public async Task Handle_FirstTrack_AddsItAtPositionZero()
@@ -19,7 +19,7 @@ namespace Musify.Application.Tests.PlayLists
             var track = TestEntities.Track(owner);
             await SeedAsync(owner, playList, track);
 
-            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             var link = Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
@@ -37,7 +37,7 @@ namespace Musify.Application.Tests.PlayLists
                 owner, playList, existingTrack, newTrack,
                 new PlayListHasTrack { PlayListId = playList.Id, TrackId = existingTrack.Id, Position = 0 });
 
-            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, newTrack.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [newTrack.Id]), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             var newLink = await Database.PlayListHasTracks.SingleAsync(link => link.TrackId == newTrack.Id, TestContext.Current.CancellationToken);
@@ -47,22 +47,22 @@ namespace Musify.Application.Tests.PlayLists
         [Fact]
         public async Task Handle_PlayListMissing_ReturnsNotFound()
         {
-            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(1, Guid.NewGuid(), [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
             var playList = TestEntities.PlayList(owner.Id);
             await SeedAsync(owner, stranger, playList);
 
-            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(stranger.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(stranger.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]
@@ -72,22 +72,59 @@ namespace Musify.Application.Tests.PlayLists
             var playList = TestEntities.PlayList(owner.Id);
             await SeedAsync(owner, playList);
 
-            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
 
         [Fact]
-        public async Task Handle_TrackAlreadyInPlayList_ReturnsConflict()
+        public async Task Handle_TrackAlreadyInPlayList_IsSkipped()
         {
             var owner = TestEntities.User();
             var playList = TestEntities.PlayList(owner.Id);
             var track = TestEntities.Track(owner);
             await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
 
-            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+            Assert.False(result.IsError);
+            Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task TrySaveChangesAsync_DuplicatePlayListTrack_MapsTheUniqueViolationToTheGivenError()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
+            Database.PlayListHasTracks.Add(new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 1 });
+
+            var result = await Database.TrySaveChangesAsync(Error.Conflict("Test.Duplicate", "duplicate"), TestContext.Current.CancellationToken);
+
+            Assert.Equal("Test.Duplicate", result.FirstError.Code);
+        }
+
+        [Fact]
+        public async Task Handle_SeveralTracks_AppendsThemInOrderSkippingExistingOnes()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var existing = TestEntities.Track(owner, "Existing");
+            var first = TestEntities.Track(owner, "First");
+            var second = TestEntities.Track(owner, "Second");
+            await SeedAsync(
+                owner, playList, existing, first, second,
+                new PlayListHasTrack { PlayListId = playList.Id, TrackId = existing.Id, Position = 0 });
+
+            var result = await CreateHandler().Handle(
+                new AddTracksToPlayListCommand(owner.Id, playList.Id, [first.Id, existing.Id, second.Id, first.Id]),
+                TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var links = await Database.PlayListHasTracks.OrderBy(link => link.Position).ToListAsync(TestContext.Current.CancellationToken);
+            Assert.Equal([existing.Id, first.Id, second.Id], links.Select(link => link.TrackId));
+            Assert.Equal([0, 1, 2], links.Select(link => link.Position));
         }
     }
 }

backend/Tests/Musify.Application.Tests/PlayLists/CreatePlayListCommandHandlerTests.cs

@@ -16,11 +16,9 @@ namespace Musify.Application.Tests.PlayLists
         private CreatePlayListCommandHandler CreateHandler() => new(
             eventBus,
             Database,
-            new UploadIntentValidator(Database, storageService),
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
             NoOpLogger<CreatePlayListCommandHandler>(),
-            TestConfigurations.Storage(),
-            TestConfigurations.PlayList(),
-            TestConfigurations.UploadIntent());
+            TestConfigurations.PlayList());
 
         [Fact]
         public async Task Handle_NoPictureIntent_CreatesPlayListWithoutPictures()
@@ -71,7 +69,7 @@ namespace Musify.Application.Tests.PlayLists
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
-            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Private, result.Value.Visibility);
+            Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Private, result.Value.Visibility);
         }
 
         [Fact]
@@ -80,12 +78,12 @@ namespace Musify.Application.Tests.PlayLists
             var user = TestEntities.User();
             await SeedAsync(user);
 
-            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null, Visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null, Visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
 
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
-            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Public, result.Value.Visibility);
+            Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/PlayLists/DeletePlayListCommandHandlerTests.cs

@@ -39,7 +39,7 @@ namespace Musify.Application.Tests.PlayLists
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -48,7 +48,7 @@ namespace Musify.Application.Tests.PlayLists
 
             var result = await CreateHandler().Handle(new DeletePlayListCommand(stranger.Id, playList.Id), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
     }
 }

backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListByIdQueryHandlerTests.cs

@@ -14,7 +14,7 @@ namespace Musify.Application.Tests.PlayLists
         public async Task Handle_ExistingPlayList_ReturnsItWithCoverTrackIds()
         {
             var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
             var track = TestEntities.Track(owner);
             await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
 
@@ -37,7 +37,7 @@ namespace Musify.Application.Tests.PlayLists
         public async Task Handle_PrivatePlayList_RequestedByOwner_ReturnsIt()
         {
             var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Private);
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
             await SeedAsync(owner, playList);
 
             var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, owner.Id), TestContext.Current.CancellationToken);
@@ -50,7 +50,7 @@ namespace Musify.Application.Tests.PlayLists
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
-            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Private);
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
             await SeedAsync(owner, stranger, playList);
 
             var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, stranger.Id), TestContext.Current.CancellationToken);
@@ -62,7 +62,7 @@ namespace Musify.Application.Tests.PlayLists
         public async Task Handle_PrivatePlayList_RequestedAnonymously_ReturnsNotFound()
         {
             var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Private);
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
             await SeedAsync(owner, playList);
 
             var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);
@@ -74,7 +74,7 @@ namespace Musify.Application.Tests.PlayLists
         public async Task Handle_PublicPlayList_RequestedAnonymously_ReturnsIt()
         {
             var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
             await SeedAsync(owner, playList);
 
             var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);

backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListCoverQueryHandlerTests.cs

@@ -1,51 +0,0 @@
-using ErrorOr;
-using Musify.Application.PlayLists;
-using Musify.Application.Tests.TestSupport;
-using Xunit;
-
-namespace Musify.Application.Tests.PlayLists
-{
-    public sealed class GetPlayListCoverQueryHandlerTests : HandlerTestBase
-    {
-        private GetPlayListCoverQueryHandler CreateHandler() =>
-            new(Database, TestConfigurations.Storage("covers-bucket"), TestConfigurations.PlayList());
-
-        [Theory]
-        [InlineData("small", "small.webp")]
-        [InlineData("large", "large.webp")]
-        [InlineData("medium", "medium.webp")]
-        public async Task Handle_ExistingPlayList_ReturnsRequestedSize(string size, string expectedFileName)
-        {
-            var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id);
-            await SeedAsync(owner, playList);
-
-            var result = await CreateHandler().Handle(new GetPlayListCoverQuery(playList.Id, size), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal("covers-bucket", result.Value.Bucket);
-            Assert.EndsWith(expectedFileName, result.Value.Key);
-        }
-
-        [Fact]
-        public async Task Handle_PlayListMissing_ReturnsNotFound()
-        {
-            var result = await CreateHandler().Handle(new GetPlayListCoverQuery(Guid.NewGuid(), "small"), TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-        }
-
-        [Fact]
-        public async Task Handle_PlayListWithoutPictures_ReturnsNotFound()
-        {
-            var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id);
-            playList.Pictures = null;
-            await SeedAsync(owner, playList);
-
-            var result = await CreateHandler().Handle(new GetPlayListCoverQuery(playList.Id, "small"), TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-        }
-    }
-}

backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListTracksQueryHandlerTests.cs

@@ -2,6 +2,7 @@ using ErrorOr;
 using Musify.Application.PlayLists;
 using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
 using Xunit;
 
 namespace Musify.Application.Tests.PlayLists
@@ -22,7 +23,7 @@ namespace Musify.Application.Tests.PlayLists
                 new PlayListHasTrack { PlayListId = playList.Id, TrackId = second.Id, Position = 1 },
                 new PlayListHasTrack { PlayListId = playList.Id, TrackId = first.Id, Position = 0 });
 
-            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             Assert.Equal(["First", "Second"], result.Value.Items.Select(track => track.Title));
@@ -35,5 +36,29 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
+
+        [Fact]
+        public async Task Handle_PrivatePlayListOfAnotherUser_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: PlayListVisibility.Private);
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: 999), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_PrivatePlayListOfViewer_ReturnsTracks()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: PlayListVisibility.Private);
+            await SeedAsync(owner, playList);
+
+            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+        }
     }
 }

backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListsByUserIdQueryHandlerTests.cs

@@ -20,39 +20,46 @@ namespace Musify.Application.Tests.PlayLists
                 TestEntities.PlayList(owner.Id, "Being removed", lifeCycleStatus: LifeCycleStatus.Removing),
                 TestEntities.PlayList(other.Id, "Theirs"));
 
-            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            var playList = Assert.Single(result.Value.Items);
+            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+            var playList = Assert.Single(result.Items);
             Assert.Equal("Mine", playList.Name);
         }
 
         [Fact]
-        public async Task Handle_OnlyPublic_ReturnsOnlyPublicPlayLists()
+        public async Task Handle_AnotherViewer_ReturnsOnlyPublicPlayLists()
         {
             var owner = TestEntities.User();
             await SeedAsync(
                 owner,
-                TestEntities.PlayList(owner.Id, "Public one", visibility: PlaylistVisibility.Public),
-                TestEntities.PlayList(owner.Id, "Private one", visibility: PlaylistVisibility.Private));
+                TestEntities.PlayList(owner.Id, "Public one", visibility: PlayListVisibility.Public),
+                TestEntities.PlayList(owner.Id, "Private one", visibility: PlayListVisibility.Private));
 
-            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10, OnlyPublic: true), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            var playList = Assert.Single(result.Value.Items);
+            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10, ViewerId: 999), TestContext.Current.CancellationToken);
+            var playList = Assert.Single(result.Items);
             Assert.Equal("Public one", playList.Name);
         }
 
+        [Fact]
+        public async Task Handle_Owner_SeesPrivatePlayLists()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(
+                owner,
+                TestEntities.PlayList(owner.Id, "Public one", visibility: PlayListVisibility.Public),
+                TestEntities.PlayList(owner.Id, "Private one", visibility: PlayListVisibility.Private));
+
+            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+            Assert.Equal(2, result.Items.Count);
+        }
+
         [Fact]
         public async Task Handle_NameFilter_ReturnsOnlyMatchingPlayLists()
         {
             var owner = TestEntities.User();
             await SeedAsync(owner, TestEntities.PlayList(owner.Id, "Road Trip"), TestEntities.PlayList(owner.Id, "Study Focus"));
 
-            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: "road", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            var playList = Assert.Single(result.Value.Items);
+            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: "road", PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+            var playList = Assert.Single(result.Items);
             Assert.Equal("Road Trip", playList.Name);
         }
     }

backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListsQueryHandlerTests.cs

@@ -1,32 +0,0 @@
-using Musify.Application.PlayLists;
-using Musify.Application.Tests.TestSupport;
-using Xunit;
-
-namespace Musify.Application.Tests.PlayLists
-{
-    public sealed class GetPlayListsQueryHandlerTests : HandlerTestBase
-    {
-        private GetPlayListsQueryHandler CreateHandler() => new(Database);
-
-        [Fact]
-        public async Task Handle_ReturnsEveryPlayListPaged()
-        {
-            var owner = TestEntities.User();
-            await SeedAsync(owner, TestEntities.PlayList(owner.Id, "One"), TestEntities.PlayList(owner.Id, "Two"));
-
-            var result = await CreateHandler().Handle(new GetPlayListsQuery(PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(2, result.Value.TotalItemCount);
-        }
-
-        [Fact]
-        public async Task Handle_NoPlayLists_ReturnsEmptyPage()
-        {
-            var result = await CreateHandler().Handle(new GetPlayListsQuery(PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Empty(result.Value.Items);
-        }
-    }
-}

backend/Tests/Musify.Application.Tests/PlayLists/RemoveTrackFromPlayListCommandHandlerTests.cs

@@ -33,7 +33,7 @@ namespace Musify.Application.Tests.PlayLists
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -42,7 +42,7 @@ namespace Musify.Application.Tests.PlayLists
 
             var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(stranger.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]
@@ -56,5 +56,27 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
+
+        [Fact]
+        public async Task Handle_TrackInTheMiddle_RenumbersTheRemainingTracks()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var first = TestEntities.Track(owner, "First");
+            var second = TestEntities.Track(owner, "Second");
+            var third = TestEntities.Track(owner, "Third");
+            await SeedAsync(
+                owner, playList, first, second, third,
+                new PlayListHasTrack { PlayListId = playList.Id, TrackId = first.Id, Position = 0 },
+                new PlayListHasTrack { PlayListId = playList.Id, TrackId = second.Id, Position = 1 },
+                new PlayListHasTrack { PlayListId = playList.Id, TrackId = third.Id, Position = 2 });
+
+            var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(owner.Id, playList.Id, second.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var remaining = Database.PlayListHasTracks.OrderBy(link => link.Position).ToList();
+            Assert.Equal([first.Id, third.Id], remaining.Select(link => link.TrackId));
+            Assert.Equal([0, 1], remaining.Select(link => link.Position));
+        }
     }
 }

backend/Tests/Musify.Application.Tests/PlayLists/RequestPlayListPictureUploadCommandHandlerTests.cs

@@ -17,17 +17,20 @@ namespace Musify.Application.Tests.PlayLists
         private RequestPlayListPictureUploadCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
         {
             storageService
-                .GetUploadUrlAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TimeSpan>(), Arg.Any<CancellationToken>())
+                .GetUploadUrlAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TimeSpan>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
                 .Returns("https://storage.musify.test/presigned-upload");
 
+            var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
+
             return new RequestPlayListPictureUploadCommandHandler(
-                Database,
-                new UploadIntentValidator(Database, storageService),
-                storageService,
-                NoOpLogger<RequestPlayListPictureUploadCommandHandler>(),
-                TestConfigurations.Storage(),
-                TestConfigurations.PlayList(),
-                uploadIntentConfig ?? TestConfigurations.UploadIntent());
+                new UploadIntentIssuer(
+                    Database,
+                    storageService,
+                    new UploadIntentValidator(Database, storageService, config),
+                    TestConfigurations.Storage(),
+                    config,
+                    NoOpLogger<UploadIntentIssuer>()),
+                TestConfigurations.PlayList());
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/PlayLists/UpdatePlayListCommandHandlerTests.cs

@@ -16,11 +16,9 @@ namespace Musify.Application.Tests.PlayLists
         private UpdatePlayListCommandHandler CreateHandler() => new(
             eventBus,
             Database,
-            new UploadIntentValidator(Database, storageService),
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
             NoOpLogger<UpdatePlayListCommandHandler>(),
-            TestConfigurations.Storage(),
-            TestConfigurations.PlayList(),
-            TestConfigurations.UploadIntent());
+            TestConfigurations.PlayList());
 
         [Fact]
         public async Task Handle_Owner_RenamesPlayList()
@@ -48,7 +46,7 @@ namespace Musify.Application.Tests.PlayLists
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -59,7 +57,7 @@ namespace Musify.Application.Tests.PlayLists
 
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]
@@ -69,19 +67,19 @@ namespace Musify.Application.Tests.PlayLists
             var playList = TestEntities.PlayList(owner.Id);
             await SeedAsync(owner, playList);
 
-            var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, null, Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, null, Musify.Domain.ValueObjects.PlayListVisibility.Public);
 
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
-            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Public, result.Value.Visibility);
+            Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
         }
 
         [Fact]
         public async Task Handle_NoVisibilitySpecified_LeavesItUnchanged()
         {
             var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlaylistVisibility.Public);
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
             await SeedAsync(owner, playList);
 
             var command = new UpdatePlayListCommand(owner.Id, playList.Id, "New Name", null, null);
@@ -89,11 +87,11 @@ namespace Musify.Application.Tests.PlayLists
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
-            Assert.Equal(Musify.Domain.ValueObjects.PlaylistVisibility.Public, result.Value.Visibility);
+            Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
         }
 
         [Fact]
-        public async Task Handle_BlankNameAndDescription_LeavesThemUnchanged()
+        public async Task Handle_BlankName_LeavesItUnchangedAndBlankDescriptionClearsIt()
         {
             var owner = TestEntities.User();
             var playList = TestEntities.PlayList(owner.Id, "Original Name", "Original description");
@@ -105,7 +103,7 @@ namespace Musify.Application.Tests.PlayLists
 
             Assert.False(result.IsError);
             Assert.Equal("Original Name", result.Value.Name);
-            Assert.Equal("Original description", result.Value.Description);
+            Assert.Null(result.Value.Description);
         }
 
         [Fact]
@@ -126,7 +124,7 @@ namespace Musify.Application.Tests.PlayLists
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
-            Assert.Equal("new-cover.webp", result.Value.SmallImageKeyName);
+            Assert.Null(result.Value.SmallImageKeyName);
             var stored = await Database.PlayLists.FindAsync([playList.Id], TestContext.Current.CancellationToken);
             Assert.NotNull(stored);
             Assert.Equal("new-cover.webp", stored.Pictures?.OriginalName);

backend/Tests/Musify.Application.Tests/Services/TrackStreamIssuerTests.cs

@@ -1,4 +1,3 @@
-using Microsoft.EntityFrameworkCore;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Services;
@@ -8,90 +7,56 @@ using Xunit;
 
 namespace Musify.Application.Tests.Services
 {
-    public sealed class TrackStreamIssuerTests : HandlerTestBase
+    public sealed class TrackStreamIssuerTests
     {
         private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
 
+        public TrackStreamIssuerTests() =>
+            ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("signed-token", 120));
+
         private TrackStreamIssuer CreateIssuer(PlaybackConfiguration? playback = null) => new(
-            Database,
             ticketService,
             TestConfigurations.Track(),
             TestConfigurations.StreamGateway("https://stream.musify.test/"),
             playback ?? TestConfigurations.Playback());
 
         [Fact]
-        public async Task IssueAsync_BuildsManifestUrlAndRecordsListeningHistory()
+        public void Issue_BuildsManifestUrlAndCarriesTheListenId()
         {
-            ticketService.IssueTicket(7, Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("signed-token", 120));
-            var owner = TestEntities.User(7);
-            var track = TestEntities.Track(owner);
-            await SeedAsync(owner, track);
+            var listenId = Guid.NewGuid();
 
-            var response = await CreateIssuer().IssueAsync(track.Id, "folder-42", userId: 7, TestContext.Current.CancellationToken);
+            var response = CreateIssuer().Issue("folder-42", userId: 7, listenId);
 
             Assert.Equal("signed-token", response.Ticket);
             Assert.Equal(120, response.ExpiresInSeconds);
-            Assert.Equal(
-                "https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a",
-                response.ManifestUrl);
-
-            var history = Assert.Single(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
-            Assert.Equal(7, history.UserId);
-            Assert.Equal(track.Id, history.TrackId);
+            Assert.Equal(listenId, response.ListenId);
+            Assert.Equal("https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a", response.ManifestUrl);
         }
 
         [Fact]
-        public async Task IssueAsync_PassesTheProcessedAudioKeyPrefixToTheTicketService()
+        public void Issue_PassesTheProcessedAudioKeyPrefixToTheTicketService()
         {
-            ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
-            var owner = TestEntities.User(1);
-            var track = TestEntities.Track(owner);
-            await SeedAsync(owner, track);
-
-            await CreateIssuer().IssueAsync(track.Id, "folder-42", userId: 1, TestContext.Current.CancellationToken);
+            CreateIssuer().Issue("folder-42", userId: 1, listenId: null);
 
             ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
         }
 
         [Fact]
-        public async Task IssueAsync_AnonymousUser_SkipsListeningHistoryAndNeverThrows()
+        public void Issue_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
         {
-            ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
-            var owner = TestEntities.User(1);
-            var track = TestEntities.Track(owner);
-            await SeedAsync(owner, track);
-
-            var response = await CreateIssuer(TestConfigurations.Playback(allowAnonymousListening: true))
-                .IssueAsync(track.Id, "folder-42", userId: null, TestContext.Current.CancellationToken);
-
-            Assert.Equal("token", response.Ticket);
-            Assert.Empty(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
-        }
-
-        [Fact]
-        public async Task IssueAsync_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
-        {
-            ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
-            var owner = TestEntities.User(1);
-            var track = TestEntities.Track(owner);
-            await SeedAsync(owner, track);
-
             var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
-            await CreateIssuer(playback).IssueAsync(track.Id, "folder-42", userId: null, TestContext.Current.CancellationToken);
+
+            CreateIssuer(playback).Issue("folder-42", userId: null, listenId: null);
 
             ticketService.Received(1).IssueTicket(null, "Tracks/ProcessedAudios/folder-42/", 30L * playback.EstimatedAudioBytesPerSecond);
         }
 
         [Fact]
-        public async Task IssueAsync_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
+        public void Issue_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
         {
-            ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
-            var owner = TestEntities.User(1);
-            var track = TestEntities.Track(owner);
-            await SeedAsync(owner, track);
-
             var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
-            await CreateIssuer(playback).IssueAsync(track.Id, "folder-42", userId: 1, TestContext.Current.CancellationToken);
+
+            CreateIssuer(playback).Issue("folder-42", userId: 1, listenId: null);
 
             ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
         }

backend/Tests/Musify.Application.Tests/Services/UploadIntentValidatorTests.cs

@@ -1,4 +1,5 @@
 using ErrorOr;
+using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Services;
 using Musify.Application.Tests.TestSupport;
@@ -13,7 +14,8 @@ namespace Musify.Application.Tests.Services
         private readonly IStorageService storageService = Substitute.For<IStorageService>();
         private readonly Domain.Entities.User owner = TestEntities.User();
 
-        private UploadIntentValidator CreateValidator() => new(Database, storageService);
+        private UploadIntentValidator CreateValidator(UploadIntentConfiguration? config = null) =>
+            new(Database, storageService, config ?? TestConfigurations.UploadIntent());
 
         [Fact]
         public async Task ValidateAndLoadAsync_UploadedObjectWithinLimits_ReturnsTheIntent()
@@ -25,16 +27,27 @@ namespace Musify.Application.Tests.Services
             var intent = TestEntities.UploadIntent(owner.Id, bucket: "bucket", key: "temp/object.webp");
             await SeedAsync(owner, intent);
 
-            var result = await CreateValidator().ValidateAndLoadAsync(TestConfigurations.UploadIntent(), intent.Id, owner.Id, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             Assert.Equal(intent.Id, result.Value.Id);
         }
 
+        [Fact]
+        public async Task ValidateAndLoadAsync_IntentIssuedForAnotherPurpose_ReturnsValidationError()
+        {
+            var intent = TestEntities.UploadIntent(owner.Id, UploadIntentPurpose.TrackAudio);
+            await SeedAsync(owner, intent);
+
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
+
         [Fact]
         public async Task ValidateAndLoadAsync_IntentMissing_ReturnsNotFound()
         {
-            var result = await CreateValidator().ValidateAndLoadAsync(TestConfigurations.UploadIntent(), Guid.NewGuid(), owner.Id, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().ValidateAndLoadAsync(Guid.NewGuid(), owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
@@ -46,7 +59,7 @@ namespace Musify.Application.Tests.Services
             var intent = TestEntities.UploadIntent(owner.Id);
             await SeedAsync(owner, stranger, intent);
 
-            var result = await CreateValidator().ValidateAndLoadAsync(TestConfigurations.UploadIntent(), intent.Id, stranger.Id, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, stranger.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
@@ -57,7 +70,7 @@ namespace Musify.Application.Tests.Services
             var intent = TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Consumed);
             await SeedAsync(owner, intent);
 
-            var result = await CreateValidator().ValidateAndLoadAsync(TestConfigurations.UploadIntent(), intent.Id, owner.Id, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
         }
@@ -68,7 +81,7 @@ namespace Musify.Application.Tests.Services
             var intent = TestEntities.UploadIntent(owner.Id, expiresAt: DateTime.UtcNow.AddMinutes(-1));
             await SeedAsync(owner, intent);
 
-            var result = await CreateValidator().ValidateAndLoadAsync(TestConfigurations.UploadIntent(), intent.Id, owner.Id, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.Validation, result.FirstError.Type);
         }
@@ -83,7 +96,7 @@ namespace Musify.Application.Tests.Services
             var intent = TestEntities.UploadIntent(owner.Id);
             await SeedAsync(owner, intent);
 
-            var result = await CreateValidator().ValidateAndLoadAsync(TestConfigurations.UploadIntent(), intent.Id, owner.Id, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
@@ -101,7 +114,7 @@ namespace Musify.Application.Tests.Services
             var intent = TestEntities.UploadIntent(owner.Id);
             await SeedAsync(owner, intent);
 
-            var result = await CreateValidator().ValidateAndLoadAsync(config, intent.Id, owner.Id, TestContext.Current.CancellationToken);
+            var result = await CreateValidator(config).ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.Validation, result.FirstError.Type);
         }
@@ -111,7 +124,7 @@ namespace Musify.Application.Tests.Services
         {
             await SeedAsync(owner);
 
-            var result = await CreateValidator().CheckQuotaAsync(TestConfigurations.UploadIntent(), owner.Id, requiredBytes: 1024, requiredIntentCount: 1, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().CheckQuotaAsync(owner.Id, requiredBytes: 1024, requiredIntentCount: 1, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
         }
@@ -123,7 +136,7 @@ namespace Musify.Application.Tests.Services
             config.MaxActiveUploadIntentsPerUser = 1;
             await SeedAsync(owner, TestEntities.UploadIntent(owner.Id));
 
-            var result = await CreateValidator().CheckQuotaAsync(config, owner.Id, requiredBytes: 1, requiredIntentCount: 1, TestContext.Current.CancellationToken);
+            var result = await CreateValidator(config).CheckQuotaAsync(owner.Id, requiredBytes: 1, requiredIntentCount: 1, TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.Validation, result.FirstError.Type);
         }
@@ -138,7 +151,7 @@ namespace Musify.Application.Tests.Services
                 TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Expired),
                 TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Consumed));
 
-            var result = await CreateValidator().CheckQuotaAsync(config, owner.Id, requiredBytes: 1, requiredIntentCount: 1, TestContext.Current.CancellationToken);
+            var result = await CreateValidator(config).CheckQuotaAsync(owner.Id, requiredBytes: 1, requiredIntentCount: 1, TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
         }

backend/Tests/Musify.Application.Tests/TestSupport/HandlerTestBase.cs

@@ -12,7 +12,11 @@ namespace Musify.Application.Tests.TestSupport
 
         public async ValueTask InitializeAsync() => database = await TestDatabase.CreateAsync();
 
-        public ValueTask DisposeAsync() => database.DisposeAsync();
+        public ValueTask DisposeAsync()
+        {
+            GC.SuppressFinalize(this);
+            return database.DisposeAsync();
+        }
 
         protected static ILogger<T> NoOpLogger<T>() => NullLogger<T>.Instance;
 

backend/Tests/Musify.Application.Tests/TestSupport/TestDatabase.cs

@@ -1,7 +1,9 @@
+using ErrorOr;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
+using Musify.Infrastructure.Persistence;
 
 namespace Musify.Application.Tests.TestSupport
 {
@@ -33,99 +35,7 @@ namespace Musify.Application.Tests.TestSupport
         {
             base.OnModelCreating(modelBuilder);
 
-            modelBuilder.Entity<Track>().OwnsOne(track => track.Pictures);
-            modelBuilder.Entity<Track>().Navigation(track => track.Pictures).IsRequired();
-
-            modelBuilder.Entity<Track>().OwnsOne(track => track.Audio);
-            modelBuilder.Entity<Track>().Navigation(track => track.Audio).IsRequired();
-
-            modelBuilder.Entity<Track>()
-                .HasOne(track => track.Owner)
-                .WithMany()
-                .HasForeignKey(track => track.OwnerUserId)
-                .OnDelete(DeleteBehavior.Restrict);
-
-            modelBuilder.Entity<PlayList>().OwnsOne(playList => playList.Pictures, pictures =>
-            {
-                pictures.Property(p => p.OriginalName).IsRequired(false);
-                pictures.Property(p => p.SmallName).IsRequired(false);
-                pictures.Property(p => p.MediumName).IsRequired(false);
-                pictures.Property(p => p.LargeName).IsRequired(false);
-            });
-            modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired(false);
-
-            modelBuilder.Entity<Album>().OwnsOne(album => album.Pictures);
-            modelBuilder.Entity<Album>().Navigation(album => album.Pictures).IsRequired(false);
-
-            modelBuilder.Entity<Album>()
-                .HasOne(album => album.Owner)
-                .WithMany()
-                .HasForeignKey(album => album.OwnerUserId)
-                .OnDelete(DeleteBehavior.Restrict);
-
-            modelBuilder.Entity<AlbumHasTrack>()
-                .HasOne(albumTrack => albumTrack.Album)
-                .WithMany(album => album.AlbumTracks)
-                .HasForeignKey(albumTrack => albumTrack.AlbumId)
-                .OnDelete(DeleteBehavior.Cascade);
-
-            modelBuilder.Entity<AlbumHasTrack>()
-                .HasOne(albumTrack => albumTrack.Track)
-                .WithMany(track => track.AlbumTracks)
-                .HasForeignKey(albumTrack => albumTrack.TrackId)
-                .OnDelete(DeleteBehavior.Cascade);
-
-            modelBuilder.Entity<AlbumHasTrack>()
-                .HasIndex(albumTrack => new { albumTrack.AlbumId, albumTrack.TrackId })
-                .IsUnique();
-
-            modelBuilder.Entity<Mix>()
-                .HasIndex(mix => new { mix.UserId, mix.Position });
-
-            modelBuilder.Entity<MixItem>()
-                .HasOne(item => item.Mix)
-                .WithMany(mix => mix.Items)
-                .HasForeignKey(item => item.MixId)
-                .OnDelete(DeleteBehavior.Cascade);
-
-            modelBuilder.Entity<MixItem>()
-                .HasOne(item => item.Track)
-                .WithMany()
-                .HasForeignKey(item => item.TrackId)
-                .OnDelete(DeleteBehavior.Cascade);
-
-            modelBuilder.Entity<MixItem>()
-                .HasIndex(item => new { item.MixId, item.Position });
-
-            modelBuilder.Entity<TrackLike>()
-                .HasIndex(like => new { like.UserId, like.TrackId })
-                .IsUnique();
-
-            modelBuilder.Entity<TrackTag>()
-                .HasOne(trackTag => trackTag.Track)
-                .WithMany(track => track.Tags)
-                .HasForeignKey(trackTag => trackTag.TrackId)
-                .OnDelete(DeleteBehavior.Cascade);
-
-            modelBuilder.Entity<TrackTag>()
-                .HasIndex(trackTag => new { trackTag.TrackId, trackTag.Tag })
-                .IsUnique();
-
-            modelBuilder.Entity<UserFollow>()
-                .HasOne(follow => follow.Follower)
-                .WithMany()
-                .HasForeignKey(follow => follow.FollowerId)
-                .OnDelete(DeleteBehavior.Restrict);
-
-            modelBuilder.Entity<UserFollow>()
-                .HasOne(follow => follow.Followed)
-                .WithMany()
-                .HasForeignKey(follow => follow.FollowedId)
-                .OnDelete(DeleteBehavior.Restrict);
-
-            modelBuilder.Entity<UserFollow>()
-                .HasIndex(follow => new { follow.FollowerId, follow.FollowedId })
-                .IsUnique();
+            ModelConfiguration.Apply(modelBuilder);
         }
 
         public DbSet<User> Users => Set<User>();
@@ -138,16 +48,12 @@ namespace Musify.Application.Tests.TestSupport
 
         public DbSet<Track> Tracks => Set<Track>();
 
-        public DbSet<UserHasTrack> UserHasTracks => Set<UserHasTrack>();
-
         public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
 
         public DbSet<Mix> Mixes => Set<Mix>();
 
         public DbSet<MixItem> MixItems => Set<MixItem>();
 
-        public DbSet<Upload> Uploads => Set<Upload>();
-
         public DbSet<UploadIntent> UploadIntents => Set<UploadIntent>();
 
         public DbSet<ListeningHistory> ListeningHistories => Set<ListeningHistory>();
@@ -164,6 +70,19 @@ namespace Musify.Application.Tests.TestSupport
             return new SqliteDatabaseTransaction(transaction);
         }
 
+        public async Task<ErrorOr<Success>> TrySaveChangesAsync(Error onUniqueViolation, CancellationToken cancellationToken)
+        {
+            try
+            {
+                await SaveChangesAsync(cancellationToken);
+                return Result.Success;
+            }
+            catch (DbUpdateException exception) when (exception.InnerException is SqliteException { SqliteErrorCode: 19 })
+            {
+                return onUniqueViolation;
+            }
+        }
+
         public override async ValueTask DisposeAsync()
         {
             await base.DisposeAsync();

backend/Tests/Musify.Application.Tests/TestSupport/TestEntities.cs

@@ -79,7 +79,7 @@ namespace Musify.Application.Tests.TestSupport
             return track;
         }
 
-        public static PlayListPictures PlayListPictures() => new()
+        public static EntityPictures PlayListPictures() => new()
         {
             OriginalName = "original.webp",
             SmallName = "small.webp",
@@ -91,12 +91,12 @@ namespace Musify.Application.Tests.TestSupport
             long userId,
             string name = "Test Playlist",
             string? description = null,
-            PlayListPictures? pictures = null,
+            EntityPictures? pictures = null,
             LifeCycleStatus lifeCycleStatus = LifeCycleStatus.Active,
-            PlaylistVisibility visibility = PlaylistVisibility.Private) =>
+            PlayListVisibility visibility = PlayListVisibility.Private) =>
             new()
             {
-                UserId = userId,
+                OwnerUserId = userId,
                 Name = name,
                 NormalizedName = name.ToUpperInvariant(),
                 Description = description,
@@ -105,7 +105,7 @@ namespace Musify.Application.Tests.TestSupport
                 Visibility = visibility
             };
 
-        public static AlbumPictures AlbumPictures() => new()
+        public static EntityPictures AlbumPictures() => new()
         {
             OriginalName = "original.webp",
             SmallName = "small.webp",
@@ -118,7 +118,7 @@ namespace Musify.Application.Tests.TestSupport
             string title = "Test Album",
             string? description = null,
             int? releaseYear = 2024,
-            AlbumPictures? pictures = null) =>
+            EntityPictures? pictures = null) =>
             new()
             {
                 Title = title,
@@ -154,14 +154,12 @@ namespace Musify.Application.Tests.TestSupport
 
         public static Mix Mix(
             long userId,
-            string title = "Test Mix",
-            string? subtitle = null,
+            MixKind kind = MixKind.Discovery,
             int position = 0) =>
             new()
             {
                 UserId = userId,
-                Title = title,
-                Subtitle = subtitle,
+                Kind = kind,
                 Position = position
             };
 

backend/Tests/Musify.Application.Tests/Tracks/CreateTrackCommandHandlerTests.cs

@@ -24,17 +24,28 @@ namespace Musify.Application.Tests.Tracks
             return new CreateTrackCommandHandler(
                 Database,
                 eventBus,
-                new UploadIntentValidator(Database, storageService),
+                new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
                 NoOpLogger<CreateTrackCommandHandler>(),
-                TestConfigurations.Storage(),
-                TestConfigurations.Track(),
-                TestConfigurations.UploadIntent());
+                TestConfigurations.Track());
         }
 
         private static (Domain.Entities.UploadIntent Picture, Domain.Entities.UploadIntent Audio) SeedIntents(long userId) =>
             (TestEntities.UploadIntent(userId, UploadIntentPurpose.TrackPicture, objectName: "cover.webp"),
              TestEntities.UploadIntent(userId, UploadIntentPurpose.TrackAudio, objectName: "song.mp3"));
 
+        [Fact]
+        public async Task Handle_SameIntentForPictureAndAudio_ReturnsValidationError()
+        {
+            var user = TestEntities.User();
+            var (picture, audio) = SeedIntents(user.Id);
+            await SeedAsync(user, picture, audio);
+
+            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, picture.Id, [Genre.Pop]);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
+
         [Fact]
         public async Task Handle_ValidIntents_CreatesTrackAndPublishesEvent()
         {
@@ -78,34 +89,6 @@ namespace Musify.Application.Tests.Tracks
             Assert.Equal(isExplicit, stored.IsExplicit);
         }
 
-        [Fact]
-        public async Task Handle_NoTags_ReturnsValidationError()
-        {
-            var user = TestEntities.User();
-            var (picture, audio) = SeedIntents(user.Id);
-            await SeedAsync(user, picture, audio);
-
-            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, []);
-
-            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-        }
-
-        [Fact]
-        public async Task Handle_IncompatibleTags_ReturnsValidationError()
-        {
-            var user = TestEntities.User();
-            var (picture, audio) = SeedIntents(user.Id);
-            await SeedAsync(user, picture, audio);
-
-            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Classical, Genre.Metal]);
-
-            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-        }
-
         [Fact]
         public async Task Handle_UserMissing_ReturnsNotFound()
         {

backend/Tests/Musify.Application.Tests/Tracks/DeleteTrackCommandHandlerTests.cs

@@ -39,7 +39,7 @@ namespace Musify.Application.Tests.Tracks
         }
 
         [Fact]
-        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        public async Task Handle_NotOwner_ReturnsForbidden()
         {
             var owner = TestEntities.User(1, "owner");
             var stranger = TestEntities.User(2, "stranger");
@@ -48,7 +48,7 @@ namespace Musify.Application.Tests.Tracks
 
             var result = await CreateHandler().Handle(new DeleteTrackCommand(stranger.Id, track.Id), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/Tracks/GetLastTrackListenedByUserIdQueryHandlerTests.cs

@@ -1,4 +1,3 @@
-using ErrorOr;
 using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
 using Xunit;
@@ -22,19 +21,19 @@ namespace Musify.Application.Tests.Tracks
 
             var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
 
-            Assert.False(result.IsError);
-            Assert.Equal("Newer listen", result.Value.Title);
+            Assert.NotNull(result);
+            Assert.Equal("Newer listen", result.Title);
         }
 
         [Fact]
-        public async Task Handle_NoHistory_ReturnsNotFound()
+        public async Task Handle_NoHistory_ReturnsNull()
         {
             var owner = TestEntities.User();
             await SeedAsync(owner);
 
             var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
 
-            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+            Assert.Null(result);
         }
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/GetTrackCoverQueryHandlerTests.cs

@@ -1,52 +0,0 @@
-using ErrorOr;
-using Musify.Application.Tests.TestSupport;
-using Musify.Application.Tracks;
-using Xunit;
-
-namespace Musify.Application.Tests.Tracks
-{
-    public sealed class GetTrackCoverQueryHandlerTests : HandlerTestBase
-    {
-        private GetTrackCoverQueryHandler CreateHandler() =>
-            new(Database, TestConfigurations.Storage("covers-bucket"), TestConfigurations.Track());
-
-        [Theory]
-        [InlineData("small", "small.webp")]
-        [InlineData("medium", "medium.webp")]
-        [InlineData("large", "large.webp")]
-        [InlineData("unknown-size-falls-back-to-medium", "medium.webp")]
-        public async Task Handle_ProcessedTrack_ReturnsRequestedSize(string size, string expectedFileName)
-        {
-            var owner = TestEntities.User();
-            var track = TestEntities.Track(owner);
-            await SeedAsync(owner, track);
-
-            var result = await CreateHandler().Handle(new GetTrackCoverQuery(track.Id, size), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal("covers-bucket", result.Value.Bucket);
-            Assert.EndsWith(expectedFileName, result.Value.Key);
-            Assert.Equal("image/webp", result.Value.ContentType);
-        }
-
-        [Fact]
-        public async Task Handle_TrackMissing_ReturnsNotFound()
-        {
-            var result = await CreateHandler().Handle(new GetTrackCoverQuery(Guid.NewGuid(), "small"), TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-        }
-
-        [Fact]
-        public async Task Handle_PictureNotProcessedYet_ReturnsNotFound()
-        {
-            var owner = TestEntities.User();
-            var track = TestEntities.Track(owner, pictures: TestEntities.PendingPictures());
-            await SeedAsync(owner, track);
-
-            var result = await CreateHandler().Handle(new GetTrackCoverQuery(track.Id, "small"), TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-        }
-    }
-}

backend/Tests/Musify.Application.Tests/Tracks/GetTracksByUserIdQueryHandlerTests.cs

@@ -1,6 +1,5 @@
 using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
-using Musify.Domain.Entities;
 using Xunit;
 
 namespace Musify.Application.Tests.Tracks
@@ -17,9 +16,7 @@ namespace Musify.Application.Tests.Tracks
             var mine = TestEntities.Track(owner, "Mine");
             var theirs = TestEntities.Track(other, "Theirs");
             await SeedAsync(
-                owner, other, mine, theirs,
-                new UserHasTrack { UserId = owner.Id, TrackId = mine.Id },
-                new UserHasTrack { UserId = other.Id, TrackId = theirs.Id });
+                owner, other, mine, theirs);
 
             var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
@@ -27,20 +24,5 @@ namespace Musify.Application.Tests.Tracks
             var track = Assert.Single(result.Value.Items);
             Assert.Equal("Mine", track.Title);
         }
-
-        [Theory]
-        [InlineData(0, 1)]
-        [InlineData(-5, 1)]
-        public async Task Handle_NonPositivePageNumber_FallsBackToFirstPage(int requestedPageNumber, int expectedPageNumber)
-        {
-            var owner = TestEntities.User();
-            var track = TestEntities.Track(owner);
-            await SeedAsync(owner, track, new UserHasTrack { UserId = owner.Id, TrackId = track.Id });
-
-            var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, Name: null, PageNumber: requestedPageNumber, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(expectedPageNumber, result.Value.PageNumber);
-        }
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/GetTracksQueryHandlerTests.cs

@@ -16,15 +16,11 @@ namespace Musify.Application.Tests.Tracks
             var trackA = TestEntities.Track(owner, "Alpha");
             var trackB = TestEntities.Track(owner, "Beta");
             await SeedAsync(
-                owner, trackA, trackB,
-                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = trackA.Id },
-                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = trackB.Id });
+                owner, trackA, trackB);
 
             var result = await CreateHandler().Handle(new GetTracksQuery(Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(2, result.Value.TotalItemCount);
-            Assert.Equal(2, result.Value.Items.Count);
+            Assert.Equal(2, result.TotalItemCount);
+            Assert.Equal(2, result.Items.Count);
         }
 
         [Fact]
@@ -34,15 +30,11 @@ namespace Musify.Application.Tests.Tracks
             var match = TestEntities.Track(owner, "Bohemian Rhapsody");
             var other = TestEntities.Track(owner, "Imagine");
             await SeedAsync(
-                owner, match, other,
-                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = match.Id },
-                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = other.Id });
+                owner, match, other);
 
             var result = await CreateHandler().Handle(new GetTracksQuery(Name: "rhapsody", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            var item = Assert.Single(result.Value.Items);
-            Assert.Equal("Bohemian Rhapsody", item.Track.Title);
+            var item = Assert.Single(result.Items);
+            Assert.Equal("Bohemian Rhapsody", item.Title);
         }
 
         [Fact]
@@ -52,15 +44,11 @@ namespace Musify.Application.Tests.Tracks
             var rock = TestEntities.Track(owner, "Loud", tags: [Genre.Rock, Genre.Indie]);
             var jazz = TestEntities.Track(owner, "Smooth", tags: [Genre.Jazz]);
             await SeedAsync(
-                owner, rock, jazz,
-                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = rock.Id },
-                new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
+                owner, rock, jazz);
 
             var result = await CreateHandler().Handle(new GetTracksQuery(null, 1, 10, Genre.Indie), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            var item = Assert.Single(result.Value.Items);
-            Assert.Equal("Loud", item.Track.Title);
+            var item = Assert.Single(result.Items);
+            Assert.Equal("Loud", item.Title);
         }
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/RecordListeningProgressCommandHandlerTests.cs

@@ -110,18 +110,5 @@ namespace Musify.Application.Tests.Tracks
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
 
-        [Theory]
-        [InlineData(-1)]
-        [InlineData(double.NaN)]
-        [InlineData(double.PositiveInfinity)]
-        public async Task Handle_InvalidSeconds_ReturnsValidationError(double seconds)
-        {
-            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
-
-            var result = await CreateHandler().Handle(
-                new RecordListeningProgressCommand(user.Id, listen.Id, seconds), TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-        }
     }
 }

backend/Tests/Musify.Application.Tests/Tracks/RequestTrackUploadUrlsCommandHandlerTests.cs

@@ -18,17 +18,22 @@ namespace Musify.Application.Tests.Tracks
         private RequestTrackUploadUrlsCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
         {
             storageService
-                .GetUploadUrlAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TimeSpan>(), Arg.Any<CancellationToken>())
+                .GetUploadUrlAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TimeSpan>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
                 .Returns("https://storage.musify.test/presigned-upload");
 
+            var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
+
             return new RequestTrackUploadUrlsCommandHandler(
-                Database,
-                new UploadIntentValidator(Database, storageService),
-                storageService,
-                NoOpLogger<RequestTrackUploadUrlsCommandHandler>(),
+                new UploadIntentIssuer(
+                    Database,
+                    storageService,
+                    new UploadIntentValidator(Database, storageService, config),
+                    TestConfigurations.Storage(),
+                    config,
+                    NoOpLogger<UploadIntentIssuer>()),
                 TestConfigurations.Storage(),
                 TestConfigurations.Track(),
-                uploadIntentConfig ?? TestConfigurations.UploadIntent());
+                config);
         }
 
         [Fact]

backend/Tests/Musify.Application.Tests/Tracks/StartListeningCommandHandlerTests.cs

@@ -10,22 +10,21 @@ using Xunit;
 
 namespace Musify.Application.Tests.Tracks
 {
-    public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
+    public sealed class StartListeningCommandHandlerTests : HandlerTestBase
     {
         private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
 
-        private GetTrackStreamQueryHandler CreateHandler(PlaybackConfiguration? playback = null)
+        private StartListeningCommandHandler CreateHandler(PlaybackConfiguration? playback = null)
         {
             ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("ticket-token", 60));
 
             var issuer = new TrackStreamIssuer(
-                Database,
                 ticketService,
                 TestConfigurations.Track(),
                 TestConfigurations.StreamGateway("https://stream.musify.test"),
                 playback ?? TestConfigurations.Playback());
 
-            return new GetTrackStreamQueryHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<GetTrackStreamQueryHandler>());
+            return new StartListeningCommandHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<StartListeningCommandHandler>());
         }
 
         [Fact]
@@ -35,7 +34,7 @@ namespace Musify.Application.Tests.Tracks
             var track = TestEntities.Track(owner);
             await SeedAsync(owner, track);
 
-            var result = await CreateHandler().Handle(new GetTrackStreamQuery(track.Id, owner.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             Assert.Equal("ticket-token", result.Value.Ticket);
@@ -53,7 +52,7 @@ namespace Musify.Application.Tests.Tracks
         [Fact]
         public async Task Handle_TrackMissing_ReturnsNotFound()
         {
-            var result = await CreateHandler().Handle(new GetTrackStreamQuery(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new StartListeningCommand(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
         }
@@ -65,7 +64,7 @@ namespace Musify.Application.Tests.Tracks
             var track = TestEntities.Track(owner, audio: TestEntities.PendingAudio());
             await SeedAsync(owner, track);
 
-            var result = await CreateHandler().Handle(new GetTrackStreamQuery(track.Id, owner.Id), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
         }
@@ -79,7 +78,7 @@ namespace Musify.Application.Tests.Tracks
 
             var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: false));
 
-            var result = await handler.Handle(new GetTrackStreamQuery(track.Id, UserId: null), TestContext.Current.CancellationToken);
+            var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
 
             Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
         }
@@ -93,7 +92,7 @@ namespace Musify.Application.Tests.Tracks
 
             var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: true));
 
-            var result = await handler.Handle(new GetTrackStreamQuery(track.Id, UserId: null), TestContext.Current.CancellationToken);
+            var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
 
             Assert.False(result.IsError);
             Assert.Equal("ticket-token", result.Value.Ticket);

backend/Tests/Musify.Application.Tests/UploadIntents/UploadIntentJobsCommandHandlerTests.cs

@@ -0,0 +1,72 @@
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.UploadIntents;
+using Musify.Domain.ValueObjects;
+using NSubstitute;
+using Xunit;
+
+namespace Musify.Application.Tests.UploadIntents
+{
+    public sealed class UploadIntentJobsCommandHandlerTests : HandlerTestBase
+    {
+        [Fact]
+        public async Task ExpireUploadIntents_OverdueIssuedIntent_IsMarkedExpired()
+        {
+            var owner = TestEntities.User();
+            var overdue = TestEntities.UploadIntent(owner.Id, expiresAt: DateTime.UtcNow.AddMinutes(-5));
+            var active = TestEntities.UploadIntent(owner.Id, expiresAt: DateTime.UtcNow.AddMinutes(5));
+            await SeedAsync(owner, overdue, active);
+            var handler = new ExpireUploadIntentsCommandHandler(
+                Database, TestConfigurations.UploadIntent(), NoOpLogger<ExpireUploadIntentsCommandHandler>());
+
+            var changed = await handler.Handle(new ExpireUploadIntentsCommand(), TestContext.Current.CancellationToken);
+
+            Assert.Equal(1, changed);
+            var stored = await Database.UploadIntents.AsNoTracking().ToListAsync(TestContext.Current.CancellationToken);
+            Assert.Equal(UploadIntentStatus.Expired, stored.Single(intent => intent.Id == overdue.Id).Status);
+            Assert.Equal(UploadIntentStatus.Issued, stored.Single(intent => intent.Id == active.Id).Status);
+        }
+
+        [Fact]
+        public async Task ExpireUploadIntents_IntentExpiredLongAgo_IsDeleted()
+        {
+            var owner = TestEntities.User();
+            var old = TestEntities.UploadIntent(
+                owner.Id, status: UploadIntentStatus.Expired, expiresAt: DateTime.UtcNow.AddDays(-30));
+            await SeedAsync(owner, old);
+            var handler = new ExpireUploadIntentsCommandHandler(
+                Database, TestConfigurations.UploadIntent(), NoOpLogger<ExpireUploadIntentsCommandHandler>());
+
+            await handler.Handle(new ExpireUploadIntentsCommand(), TestContext.Current.CancellationToken);
+
+            Assert.Empty(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+        }
+
+        [Fact]
+        public async Task DeleteStaleTempUploads_RemovesOnlyObjectsOlderThanTheRetention()
+        {
+            var storage = Substitute.For<IStorageService>();
+            storage.ListObjectsAsync("test-bucket", "temp", Arg.Any<CancellationToken>()).Returns(Objects(
+                new StorageObject("temp/old", DateTime.UtcNow.AddDays(-10)),
+                new StorageObject("temp/new", DateTime.UtcNow)));
+            var handler = new DeleteStaleTempUploadsCommandHandler(
+                storage, TestConfigurations.Storage("test-bucket"), TestConfigurations.UploadIntent(),
+                NoOpLogger<DeleteStaleTempUploadsCommandHandler>());
+
+            var deleted = await handler.Handle(new DeleteStaleTempUploadsCommand(), TestContext.Current.CancellationToken);
+
+            Assert.Equal(1, deleted);
+            await storage.Received(1).RemoveFileAsync("test-bucket", "temp/old", Arg.Any<CancellationToken>());
+            await storage.DidNotReceive().RemoveFileAsync("test-bucket", "temp/new", Arg.Any<CancellationToken>());
+        }
+
+        private static async IAsyncEnumerable<StorageObject> Objects(params StorageObject[] objects)
+        {
+            foreach (var item in objects)
+                yield return item;
+
+            await Task.CompletedTask;
+        }
+    }
+}

backend/Tests/Musify.Application.Tests/Users/CreateUserCommandHandlerTests.cs

@@ -1,41 +0,0 @@
-using ErrorOr;
-using Musify.Application.Tests.TestSupport;
-using Musify.Application.Users;
-using Xunit;
-
-namespace Musify.Application.Tests.Users
-{
-    public sealed class CreateUserCommandHandlerTests : HandlerTestBase
-    {
-        private CreateUserCommandHandler CreateHandler() => new(Database, NoOpLogger<CreateUserCommandHandler>());
-
-        [Fact]
-        public async Task Handle_NewId_CreatesUser()
-        {
-            var command = new CreateUserCommand(1, "Jane Doe", "Jane", "Doe");
-
-            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal("Jane Doe", result.Value.Name);
-            Assert.Equal(1, result.Value.Id);
-
-            var stored = await Database.Users.FindAsync([1L], TestContext.Current.CancellationToken);
-            Assert.NotNull(stored);
-            Assert.Equal("JANE DOE", stored.NormalizedName);
-        }
-
-        [Fact]
-        public async Task Handle_IdAlreadyExists_ReturnsConflict()
-        {
-            var existing = TestEntities.User(1);
-            await SeedAsync(existing);
-
-            var command = new CreateUserCommand(1, "Someone Else", null, null);
-
-            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
-
-            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
-        }
-    }
-}

backend/Tests/Musify.Application.Tests/Users/GetListeningStatsQueryHandlerTests.cs

@@ -102,7 +102,7 @@ namespace Musify.Application.Tests.Users
         }
 
         [Fact]
-        public async Task Handle_NoListenToday_StreakIsZero()
+        public async Task Handle_ListenedYesterdayButNotToday_StreakIsStillAlive()
         {
             var user = TestEntities.User();
             var track = TestEntities.Track(user);
@@ -112,6 +112,20 @@ namespace Musify.Application.Tests.Users
 
             var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
+            Assert.Equal(1, result.StreakDays);
+        }
+
+        [Fact]
+        public async Task Handle_NoListenTodayOrYesterday_StreakIsZero()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-2)));
+
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
             Assert.Equal(0, result.StreakDays);
         }
     }

backend/Tests/Musify.Application.Tests/Users/GetUsersQueryHandlerTests.cs

@@ -15,9 +15,7 @@ namespace Musify.Application.Tests.Users
             await SeedAsync(TestEntities.User(1, "alice"), TestEntities.User(2, "bob"));
 
             var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: null), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.Equal(2, result.Value.TotalItemCount);
+            Assert.Equal(2, result.TotalItemCount);
         }
 
         [Fact]
@@ -26,9 +24,7 @@ namespace Musify.Application.Tests.Users
             await SeedAsync(TestEntities.User(1, "alice-wonderland"), TestEntities.User(2, "bob-builder"));
 
             var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: "alice"), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            var user = Assert.Single(result.Value.Items);
+            var user = Assert.Single(result.Items);
             Assert.Equal(1, user.Id);
         }
 
@@ -40,9 +36,7 @@ namespace Musify.Application.Tests.Users
                 new UserFollow { FollowerId = 1, FollowedId = 2 });
 
             var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: null, ViewerId: 1), TestContext.Current.CancellationToken);
-
-            Assert.False(result.IsError);
-            Assert.All(result.Value.Items, item => Assert.Equal(item.Id == 2, item.IsFollowedByViewer));
+            Assert.All(result.Items, item => Assert.Equal(item.Id == 2, item.IsFollowedByViewer));
         }
     }
 }