Change editor rule

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

@@ -5,108 +5,109 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class AddTracksToAlbumCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private AddTracksToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToAlbumCommandHandler>());
-
-    [Fact]
-    public async Task Handle_FirstTrack_AddsItAtNumberOne()
+    public sealed class AddTracksToAlbumCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, album, track);
+        private AddTracksToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToAlbumCommandHandler>());
 
-        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_FirstTrack_AddsItAtNumberOne()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, album, track);
 
-        Assert.False(result.IsError);
-        var link = Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
-        Assert.Equal(1, link.TrackNumber);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AlbumMissing_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
+            Assert.False(result.IsError);
+            var link = Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
+            Assert.Equal(1, link.TrackNumber);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, Guid.NewGuid(), [track.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_AlbumMissing_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, Guid.NewGuid(), [track.Id]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NotOwner_ReturnsForbidden()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var stranger = TestEntities.User(2, "stranger");
-        var album = TestEntities.Album(owner.Id);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, stranger, album, track);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(stranger.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsForbidden()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var album = TestEntities.Album(owner.Id);
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, stranger, album, track);
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(stranger.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackMissing_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        await SeedAsync(owner, album);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackMissing_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, album);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackOwnedByAnotherUser_ReturnsForbidden()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var otherOwner = TestEntities.User(2, "other");
-        var album = TestEntities.Album(owner.Id);
-        var foreignTrack = TestEntities.Track(otherOwner);
-        await SeedAsync(owner, otherOwner, album, foreignTrack);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [foreignTrack.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackOwnedByAnotherUser_ReturnsForbidden()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var otherOwner = TestEntities.User(2, "other");
+            var album = TestEntities.Album(owner.Id);
+            var foreignTrack = TestEntities.Track(otherOwner);
+            await SeedAsync(owner, otherOwner, album, foreignTrack);
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [foreignTrack.Id]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AlreadyInAlbum_IsSkipped()
-    {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        var track = TestEntities.Track(owner);
-        var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
-        await SeedAsync(owner, album, track, link);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_AlreadyInAlbum_IsSkipped()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            var track = TestEntities.Track(owner);
+            var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
+            await SeedAsync(owner, album, track, link);
 
-        Assert.False(result.IsError);
-        Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AlbumAlreadyHasTracks_AppendsAtNextNumber()
-    {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        var firstTrack = TestEntities.Track(owner, "First");
-        var secondTrack = TestEntities.Track(owner, "Second");
-        var existingLink = new AlbumHasTrack { AlbumId = album.Id, TrackId = firstTrack.Id, TrackNumber = 3 };
-        await SeedAsync(owner, album, firstTrack, secondTrack, existingLink);
+            Assert.False(result.IsError);
+            Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [secondTrack.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_AlbumAlreadyHasTracks_AppendsAtNextNumber()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            var firstTrack = TestEntities.Track(owner, "First");
+            var secondTrack = TestEntities.Track(owner, "Second");
+            var existingLink = new AlbumHasTrack { AlbumId = album.Id, TrackId = firstTrack.Id, TrackNumber = 3 };
+            await SeedAsync(owner, album, firstTrack, secondTrack, existingLink);
 
-        Assert.False(result.IsError);
-        var newLink = await Database.AlbumHasTracks.SingleAsync(l => l.TrackId == secondTrack.Id, TestContext.Current.CancellationToken);
-        Assert.Equal(4, newLink.TrackNumber);
+            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);
+            Assert.Equal(4, newLink.TrackNumber);
+        }
     }
 }

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

@@ -6,69 +6,70 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class CreateAlbumCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private CreateAlbumCommandHandler CreateHandler() => new(
-        eventBus,
-        Database,
-        new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
-        NoOpLogger<CreateAlbumCommandHandler>(),
-        TestConfigurations.Album());
-
-    [Fact]
-    public async Task Handle_ValidPictureIntent_CreatesAlbumAndPublishesResourcesEvent()
+    public sealed class CreateAlbumCommandHandlerTests : HandlerTestBase
     {
-        storageService
-            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
-            .Returns(new ObjectMetaData("image/webp", 1024));
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        var owner = TestEntities.User();
-        var intent = TestEntities.UploadIntent(owner.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.AlbumPicture, objectName: "cover.webp");
-        await SeedAsync(owner, intent);
+        private CreateAlbumCommandHandler CreateHandler() => new(
+            eventBus,
+            Database,
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
+            NoOpLogger<CreateAlbumCommandHandler>(),
+            TestConfigurations.Album());
 
-        var command = new CreateAlbumCommand(owner.Id, "  My Album  ", "A description", 2024, intent.Id);
+        [Fact]
+        public async Task Handle_ValidPictureIntent_CreatesAlbumAndPublishesResourcesEvent()
+        {
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 1024));
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var owner = TestEntities.User();
+            var intent = TestEntities.UploadIntent(owner.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.AlbumPicture, objectName: "cover.webp");
+            await SeedAsync(owner, intent);
 
-        Assert.False(result.IsError);
-        Assert.Equal("My Album", result.Value.Title);
-        Assert.Equal("A description", result.Value.Description);
-        Assert.Equal(2024, result.Value.ReleaseYear);
-        Assert.Equal(owner.Id, result.Value.OwnerUserId);
-        Assert.Equal(0, result.Value.TrackCount);
+            var command = new CreateAlbumCommand(owner.Id, "  My Album  ", "A description", 2024, intent.Id);
 
-        var stored = await Database.Albums.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal("MY ALBUM", stored.NormalizedTitle);
-        Assert.Equal("cover.webp", stored.Pictures?.OriginalName);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreateAlbumResourcesEvent>(), Arg.Any<CancellationToken>());
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserDoesNotExist_ReturnsNotFound()
-    {
-        var command = new CreateAlbumCommand(404, "Orphan Album", null, null, Guid.NewGuid());
+            Assert.False(result.IsError);
+            Assert.Equal("My Album", result.Value.Title);
+            Assert.Equal("A description", result.Value.Description);
+            Assert.Equal(2024, result.Value.ReleaseYear);
+            Assert.Equal(owner.Id, result.Value.OwnerUserId);
+            Assert.Equal(0, result.Value.TrackCount);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var stored = await Database.Albums.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal("MY ALBUM", stored.NormalizedTitle);
+            Assert.Equal("cover.webp", stored.Pictures?.OriginalName);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreateAlbumResourcesEvent>(), Arg.Any<CancellationToken>());
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_UserDoesNotExist_ReturnsNotFound()
+        {
+            var command = new CreateAlbumCommand(404, "Orphan Album", null, null, Guid.NewGuid());
 
-    [Fact]
-    public async Task Handle_PictureIntentNotFound_ReturnsError()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new CreateAlbumCommand(owner.Id, "My Album", null, null, Guid.NewGuid());
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PictureIntentNotFound_ReturnsError()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
 
-        Assert.True(result.IsError);
+            var command = new CreateAlbumCommand(owner.Id, "My Album", null, null, Guid.NewGuid());
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.True(result.IsError);
+        }
     }
 }

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

@@ -6,49 +6,50 @@ using Musify.Domain.ValueObjects;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class DeleteAlbumCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-
-    private DeleteAlbumCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeleteAlbumCommandHandler>());
-
-    [Fact]
-    public async Task Handle_Owner_MarksAlbumAsRemoving()
+    public sealed class DeleteAlbumCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        await SeedAsync(owner, album);
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
 
-        var result = await CreateHandler().Handle(new DeleteAlbumCommand(owner.Id, album.Id), TestContext.Current.CancellationToken);
+        private DeleteAlbumCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeleteAlbumCommandHandler>());
 
-        Assert.False(result.IsError);
-        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]
+        public async Task Handle_Owner_MarksAlbumAsRemoving()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, album);
 
-    [Fact]
-    public async Task Handle_AlbumMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new DeleteAlbumCommand(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new DeleteAlbumCommand(owner.Id, album.Id), TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            Assert.False(result.IsError);
+            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]
-    public async Task Handle_NotOwner_ReturnsForbiddenAndKeepsAlbum()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var stranger = TestEntities.User(2, "stranger");
-        var album = TestEntities.Album(owner.Id);
-        await SeedAsync(owner, stranger, album);
+        [Fact]
+        public async Task Handle_AlbumMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new DeleteAlbumCommand(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-        var result = await CreateHandler().Handle(new DeleteAlbumCommand(stranger.Id, album.Id), TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-        Assert.NotNull(await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken));
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsForbiddenAndKeepsAlbum()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, stranger, album);
+
+            var result = await CreateHandler().Handle(new DeleteAlbumCommand(stranger.Id, album.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+            Assert.NotNull(await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken));
+        }
     }
 }

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

@@ -4,33 +4,34 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class GetAlbumByIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private GetAlbumByIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ExistingAlbum_ReturnsItWithTrackCountAndCovers()
+    public sealed class GetAlbumByIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, album, track, new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 });
+        private GetAlbumByIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetAlbumByIdQuery(album.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ExistingAlbum_ReturnsItWithTrackCountAndCovers()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, album, track, new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 });
 
-        Assert.False(result.IsError);
-        Assert.Equal(album.Id, result.Value.Id);
-        Assert.Equal(1, result.Value.TrackCount);
-        Assert.Equal([track.Id], result.Value.CoverTrackIds);
-    }
+            var result = await CreateHandler().Handle(new GetAlbumByIdQuery(album.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AlbumMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetAlbumByIdQuery(Guid.NewGuid()), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal(album.Id, result.Value.Id);
+            Assert.Equal(1, result.Value.TrackCount);
+            Assert.Equal([track.Id], result.Value.CoverTrackIds);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_AlbumMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetAlbumByIdQuery(Guid.NewGuid()), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -4,35 +4,36 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class GetAlbumTracksQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private GetAlbumTracksQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_AlbumWithTracks_ReturnsThemOrderedByTrackNumber()
+    public sealed class GetAlbumTracksQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        var second = TestEntities.Track(owner, "Second");
-        var first = TestEntities.Track(owner, "First");
-        await SeedAsync(
-            owner, album, second, first,
-            new AlbumHasTrack { AlbumId = album.Id, TrackId = second.Id, TrackNumber = 2 },
-            new AlbumHasTrack { AlbumId = album.Id, TrackId = first.Id, TrackNumber = 1 });
+        private GetAlbumTracksQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetAlbumTracksQuery(album.Id, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_AlbumWithTracks_ReturnsThemOrderedByTrackNumber()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            var second = TestEntities.Track(owner, "Second");
+            var first = TestEntities.Track(owner, "First");
+            await SeedAsync(
+                owner, album, second, first,
+                new AlbumHasTrack { AlbumId = album.Id, TrackId = second.Id, TrackNumber = 2 },
+                new AlbumHasTrack { AlbumId = album.Id, TrackId = first.Id, TrackNumber = 1 });
 
-        Assert.False(result.IsError);
-        Assert.Equal(["First", "Second"], result.Value.Items.Select(track => track.Title));
-    }
+            var result = await CreateHandler().Handle(new GetAlbumTracksQuery(album.Id, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AlbumMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetAlbumTracksQuery(Guid.NewGuid(), PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal(["First", "Second"], result.Value.Items.Select(track => track.Title));
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_AlbumMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetAlbumTracksQuery(Guid.NewGuid(), PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -3,31 +3,32 @@ using Musify.Application.Albums;
 using Musify.Application.Tests.TestSupport;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class GetAlbumsByUserIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private GetAlbumsByUserIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_UserWithAlbums_ReturnsOnlyTheirAlbums()
+    public sealed class GetAlbumsByUserIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User(1, "owner");
-        var other = TestEntities.User(2, "other");
-        await SeedAsync(owner, other, TestEntities.Album(owner.Id, "Mine"), TestEntities.Album(other.Id, "Theirs"));
+        private GetAlbumsByUserIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetAlbumsByUserIdQuery(owner.Id, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UserWithAlbums_ReturnsOnlyTheirAlbums()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var other = TestEntities.User(2, "other");
+            await SeedAsync(owner, other, TestEntities.Album(owner.Id, "Mine"), TestEntities.Album(other.Id, "Theirs"));
 
-        Assert.False(result.IsError);
-        var album = Assert.Single(result.Value.Items);
-        Assert.Equal("Mine", album.Title);
-    }
+            var result = await CreateHandler().Handle(new GetAlbumsByUserIdQuery(owner.Id, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetAlbumsByUserIdQuery(404, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            var album = Assert.Single(result.Value.Items);
+            Assert.Equal("Mine", album.Title);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetAlbumsByUserIdQuery(404, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -2,42 +2,43 @@ using Musify.Application.Albums;
 using Musify.Application.Tests.TestSupport;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class GetAlbumsQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private GetAlbumsQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_NoTitleFilter_ReturnsAllAlbumsPaged()
+    public sealed class GetAlbumsQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        await SeedAsync(owner, TestEntities.Album(owner.Id, "Alpha"), TestEntities.Album(owner.Id, "Beta"));
+        private GetAlbumsQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetAlbumsQuery(Title: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-        Assert.Equal(2, result.TotalItemCount);
-        Assert.All(result.Items, item => Assert.NotNull(item));
-    }
+        [Fact]
+        public async Task Handle_NoTitleFilter_ReturnsAllAlbumsPaged()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner, TestEntities.Album(owner.Id, "Alpha"), TestEntities.Album(owner.Id, "Beta"));
 
-    [Fact]
-    public async Task Handle_TitleFilter_ReturnsMatchingAlbumsOnly()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner, TestEntities.Album(owner.Id, "Rock Classics"), TestEntities.Album(owner.Id, "Jazz Favorites"));
+            var result = await CreateHandler().Handle(new GetAlbumsQuery(Title: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            Assert.Equal(2, result.TotalItemCount);
+            Assert.All(result.Items, item => Assert.NotNull(item));
+        }
 
-        var result = await CreateHandler().Handle(new GetAlbumsQuery(Title: "rock", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-        var item = Assert.Single(result.Items);
-        Assert.Equal("Rock Classics", item.Title);
-    }
+        [Fact]
+        public async Task Handle_TitleFilter_ReturnsMatchingAlbumsOnly()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner, TestEntities.Album(owner.Id, "Rock Classics"), TestEntities.Album(owner.Id, "Jazz Favorites"));
 
-    [Fact]
-    public async Task Handle_PageSizeSmallerThanTotal_ReportsHasNextPage()
-    {
-        var owner = TestEntities.User();
-        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: "rock", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            var item = Assert.Single(result.Items);
+            Assert.Equal("Rock Classics", item.Title);
+        }
 
-        var result = await CreateHandler().Handle(new GetAlbumsQuery(Title: null, PageNumber: 1, PageSize: 2), TestContext.Current.CancellationToken);
-        Assert.Equal(2, result.Items.Count);
-        Assert.True(result.HasNextPage);
+        [Fact]
+        public async Task Handle_PageSizeSmallerThanTotal_ReportsHasNextPage()
+        {
+            var owner = TestEntities.User();
+            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.Equal(2, result.Items.Count);
+            Assert.True(result.HasNextPage);
+        }
     }
 }

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

@@ -3,72 +3,73 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class GetRecentlyListenedAlbumsQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private GetRecentlyListenedAlbumsQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ListenedTracks_ReturnsTheirAlbumsMostRecentFirst()
+    public sealed class GetRecentlyListenedAlbumsQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var olderAlbum = TestEntities.Album(owner.Id, "Older");
-        var newerAlbum = TestEntities.Album(owner.Id, "Newer");
-        var olderTrack = TestEntities.Track(owner, "In older album");
-        var newerTrack = TestEntities.Track(owner, "In newer album");
-        await SeedAsync(
-            owner, olderAlbum, newerAlbum, olderTrack, newerTrack,
-            new AlbumHasTrack { AlbumId = olderAlbum.Id, TrackId = olderTrack.Id, TrackNumber = 1 },
-            new AlbumHasTrack { AlbumId = newerAlbum.Id, TrackId = newerTrack.Id, TrackNumber = 1 },
-            TestEntities.ListeningHistory(owner.Id, olderTrack.Id, DateTime.UtcNow.AddDays(-2)),
-            TestEntities.ListeningHistory(owner.Id, newerTrack.Id, DateTime.UtcNow.AddDays(-1)));
+        private GetRecentlyListenedAlbumsQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
-        Assert.Equal(["Newer", "Older"], result.Select(album => album.Title));
-    }
+        [Fact]
+        public async Task Handle_ListenedTracks_ReturnsTheirAlbumsMostRecentFirst()
+        {
+            var owner = TestEntities.User();
+            var olderAlbum = TestEntities.Album(owner.Id, "Older");
+            var newerAlbum = TestEntities.Album(owner.Id, "Newer");
+            var olderTrack = TestEntities.Track(owner, "In older album");
+            var newerTrack = TestEntities.Track(owner, "In newer album");
+            await SeedAsync(
+                owner, olderAlbum, newerAlbum, olderTrack, newerTrack,
+                new AlbumHasTrack { AlbumId = olderAlbum.Id, TrackId = olderTrack.Id, TrackNumber = 1 },
+                new AlbumHasTrack { AlbumId = newerAlbum.Id, TrackId = newerTrack.Id, TrackNumber = 1 },
+                TestEntities.ListeningHistory(owner.Id, olderTrack.Id, DateTime.UtcNow.AddDays(-2)),
+                TestEntities.ListeningHistory(owner.Id, newerTrack.Id, DateTime.UtcNow.AddDays(-1)));
 
-    [Fact]
-    public async Task Handle_NoListeningHistory_ReturnsEmptyList()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner);
+            var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
+            Assert.Equal(["Newer", "Older"], result.Select(album => album.Title));
+        }
 
-        var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
-        Assert.Empty(result);
-    }
+        [Fact]
+        public async Task Handle_NoListeningHistory_ReturnsEmptyList()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
 
-    [Fact]
-    public async Task Handle_LimitLowerThanCandidates_ReturnsOnlyThatManyAlbums()
-    {
-        var owner = TestEntities.User();
-        var albums = Enumerable.Range(1, 3).Select(i => TestEntities.Album(owner.Id, $"Album {i}")).ToList();
-        var tracks = albums.Select((_, i) => TestEntities.Track(owner, $"Track {i}")).ToList();
-        var links = albums.Zip(tracks, (album, track) => new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 }).ToList();
-        var histories = tracks.Select((track, i) => TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddMinutes(-i))).ToList();
-        await SeedAsync([owner, .. albums, .. tracks, .. links, .. histories]);
+            var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
+            Assert.Empty(result);
+        }
 
-        var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 2), TestContext.Current.CancellationToken);
-        Assert.Equal(2, result.Count);
-    }
+        [Fact]
+        public async Task Handle_LimitLowerThanCandidates_ReturnsOnlyThatManyAlbums()
+        {
+            var owner = TestEntities.User();
+            var albums = Enumerable.Range(1, 3).Select(i => TestEntities.Album(owner.Id, $"Album {i}")).ToList();
+            var tracks = albums.Select((_, i) => TestEntities.Track(owner, $"Track {i}")).ToList();
+            var links = albums.Zip(tracks, (album, track) => new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 }).ToList();
+            var histories = tracks.Select((track, i) => TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddMinutes(-i))).ToList();
+            await SeedAsync([owner, .. albums, .. tracks, .. links, .. histories]);
 
-    [Fact]
-    public async Task Handle_UncountedListens_AreIgnored()
-    {
-        var owner = TestEntities.User();
-        var countedAlbum = TestEntities.Album(owner.Id, "Counted album");
-        var skippedAlbum = TestEntities.Album(owner.Id, "Skipped album");
-        var countedTrack = TestEntities.Track(owner, "In counted");
-        var skippedTrack = TestEntities.Track(owner, "In skipped");
-        await SeedAsync(
-            owner, countedAlbum, skippedAlbum, countedTrack, skippedTrack,
-            new AlbumHasTrack { AlbumId = countedAlbum.Id, TrackId = countedTrack.Id, TrackNumber = 1 },
-            new AlbumHasTrack { AlbumId = skippedAlbum.Id, TrackId = skippedTrack.Id, TrackNumber = 1 },
-            TestEntities.ListeningHistory(owner.Id, countedTrack.Id, DateTime.UtcNow.AddDays(-1), playedSeconds: 120),
-            TestEntities.ListeningHistory(owner.Id, skippedTrack.Id, DateTime.UtcNow, playedSeconds: 1, isCounted: false));
+            var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 2), TestContext.Current.CancellationToken);
+            Assert.Equal(2, result.Count);
+        }
 
-        var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UncountedListens_AreIgnored()
+        {
+            var owner = TestEntities.User();
+            var countedAlbum = TestEntities.Album(owner.Id, "Counted album");
+            var skippedAlbum = TestEntities.Album(owner.Id, "Skipped album");
+            var countedTrack = TestEntities.Track(owner, "In counted");
+            var skippedTrack = TestEntities.Track(owner, "In skipped");
+            await SeedAsync(
+                owner, countedAlbum, skippedAlbum, countedTrack, skippedTrack,
+                new AlbumHasTrack { AlbumId = countedAlbum.Id, TrackId = countedTrack.Id, TrackNumber = 1 },
+                new AlbumHasTrack { AlbumId = skippedAlbum.Id, TrackId = skippedTrack.Id, TrackNumber = 1 },
+                TestEntities.ListeningHistory(owner.Id, countedTrack.Id, DateTime.UtcNow.AddDays(-1), playedSeconds: 120),
+                TestEntities.ListeningHistory(owner.Id, skippedTrack.Id, DateTime.UtcNow, playedSeconds: 1, isCounted: false));
 
-        Assert.Equal(["Counted album"], result.Select(album => album.Title));
+            var result = await CreateHandler().Handle(new GetRecentlyListenedAlbumsQuery(owner.Id, Limit: 10), TestContext.Current.CancellationToken);
+
+            Assert.Equal(["Counted album"], result.Select(album => album.Title));
+        }
     }
 }

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

@@ -5,68 +5,69 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class RemoveTrackFromAlbumCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private RemoveTrackFromAlbumCommandHandler CreateHandler() =>
-        new(Database, NoOpLogger<RemoveTrackFromAlbumCommandHandler>());
-
-    [Fact]
-    public async Task Handle_TrackInAlbum_RemovesItAndRenumbersTheRest()
+    public sealed class RemoveTrackFromAlbumCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        var first = TestEntities.Track(owner, "First");
-        var second = TestEntities.Track(owner, "Second");
-        var third = TestEntities.Track(owner, "Third");
-        await SeedAsync(
-            owner, album, first, second, third,
-            new AlbumHasTrack { AlbumId = album.Id, TrackId = first.Id, TrackNumber = 1 },
-            new AlbumHasTrack { AlbumId = album.Id, TrackId = second.Id, TrackNumber = 2 },
-            new AlbumHasTrack { AlbumId = album.Id, TrackId = third.Id, TrackNumber = 3 });
+        private RemoveTrackFromAlbumCommandHandler CreateHandler() =>
+            new(Database, NoOpLogger<RemoveTrackFromAlbumCommandHandler>());
 
-        var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(owner.Id, album.Id, second.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackInAlbum_RemovesItAndRenumbersTheRest()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            var first = TestEntities.Track(owner, "First");
+            var second = TestEntities.Track(owner, "Second");
+            var third = TestEntities.Track(owner, "Third");
+            await SeedAsync(
+                owner, album, first, second, third,
+                new AlbumHasTrack { AlbumId = album.Id, TrackId = first.Id, TrackNumber = 1 },
+                new AlbumHasTrack { AlbumId = album.Id, TrackId = second.Id, TrackNumber = 2 },
+                new AlbumHasTrack { AlbumId = album.Id, TrackId = third.Id, TrackNumber = 3 });
 
-        Assert.False(result.IsError);
-        var remaining = await Database.AlbumHasTracks
-            .Where(link => link.AlbumId == album.Id)
-            .OrderBy(link => link.TrackNumber)
-            .ToListAsync(TestContext.Current.CancellationToken);
-        Assert.Equal([first.Id, third.Id], remaining.Select(link => link.TrackId));
-        Assert.Equal([1, 2], remaining.Select(link => link.TrackNumber));
-    }
+            var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(owner.Id, album.Id, second.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AlbumMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            var remaining = await Database.AlbumHasTracks
+                .Where(link => link.AlbumId == album.Id)
+                .OrderBy(link => link.TrackNumber)
+                .ToListAsync(TestContext.Current.CancellationToken);
+            Assert.Equal([first.Id, third.Id], remaining.Select(link => link.TrackId));
+            Assert.Equal([1, 2], remaining.Select(link => link.TrackNumber));
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_AlbumMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NotOwner_ReturnsForbidden()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var stranger = TestEntities.User(2, "stranger");
-        var album = TestEntities.Album(owner.Id);
-        await SeedAsync(owner, stranger, album);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(stranger.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsForbidden()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, stranger, album);
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(stranger.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackNotInAlbum_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id);
-        await SeedAsync(owner, album);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(owner.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackNotInAlbum_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, album);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+            var result = await CreateHandler().Handle(new RemoveTrackFromAlbumCommand(owner.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -8,70 +8,71 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class RequestAlbumPictureUploadCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private RequestAlbumPictureUploadCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
+    public sealed class RequestAlbumPictureUploadCommandHandlerTests : HandlerTestBase
     {
-        storageService
-            .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");
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
+        private RequestAlbumPictureUploadCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
+        {
+            storageService
+                .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");
 
-        return new RequestAlbumPictureUploadCommandHandler(
-            new UploadIntentIssuer(
-                Database,
-                storageService,
-                new UploadIntentValidator(Database, storageService, config),
-                TestConfigurations.Storage(),
-                config,
-                NoOpLogger<UploadIntentIssuer>()),
-            TestConfigurations.Album());
-    }
+            var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
 
-    [Fact]
-    public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+            return new RequestAlbumPictureUploadCommandHandler(
+                new UploadIntentIssuer(
+                    Database,
+                    storageService,
+                    new UploadIntentValidator(Database, storageService, config),
+                    TestConfigurations.Storage(),
+                    config,
+                    NoOpLogger<UploadIntentIssuer>()),
+                TestConfigurations.Album());
+        }
 
-        var command = new RequestAlbumPictureUploadCommand(user.Id, "webp", "image/webp");
+        [Fact]
+        public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var command = new RequestAlbumPictureUploadCommand(user.Id, "webp", "image/webp");
 
-        Assert.False(result.IsError);
-        Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.UploadUrl);
-        Assert.Single(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var command = new RequestAlbumPictureUploadCommand(404, "webp", "image/webp");
+            Assert.False(result.IsError);
+            Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.UploadUrl);
+            Assert.Single(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var command = new RequestAlbumPictureUploadCommand(404, "webp", "image/webp");
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserOverByteQuota_ReturnsValidationErrorAndCreatesNoIntent()
-    {
-        var config = TestConfigurations.UploadIntent();
-        config.MaxActiveUploadBytesPerUser = 100;
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var user = TestEntities.User();
-        await SeedAsync(user);
+        [Fact]
+        public async Task Handle_UserOverByteQuota_ReturnsValidationErrorAndCreatesNoIntent()
+        {
+            var config = TestConfigurations.UploadIntent();
+            config.MaxActiveUploadBytesPerUser = 100;
 
-        var command = new RequestAlbumPictureUploadCommand(user.Id, "webp", "image/webp", ExpectedSizeBytes: 1_000_000);
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        var result = await CreateHandler(config).Handle(command, TestContext.Current.CancellationToken);
+            var command = new RequestAlbumPictureUploadCommand(user.Id, "webp", "image/webp", ExpectedSizeBytes: 1_000_000);
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-        Assert.Empty(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+            var result = await CreateHandler(config).Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+            Assert.Empty(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+        }
     }
 }

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

@@ -6,86 +6,87 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Albums;
-
-public sealed class UpdateAlbumCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Albums
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private UpdateAlbumCommandHandler CreateHandler() => new(
-        eventBus,
-        Database,
-        new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
-        NoOpLogger<UpdateAlbumCommandHandler>(),
-        TestConfigurations.Album());
-
-    [Fact]
-    public async Task Handle_Owner_UpdatesTitleDescriptionAndReleaseYear()
+    public sealed class UpdateAlbumCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id, title: "Old Title", description: "Old", releaseYear: 2020);
-        await SeedAsync(owner, album);
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        var command = new UpdateAlbumCommand(owner.Id, album.Id, "  New Title  ", "New description", 2025, null);
+        private UpdateAlbumCommandHandler CreateHandler() => new(
+            eventBus,
+            Database,
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
+            NoOpLogger<UpdateAlbumCommandHandler>(),
+            TestConfigurations.Album());
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_Owner_UpdatesTitleDescriptionAndReleaseYear()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id, title: "Old Title", description: "Old", releaseYear: 2020);
+            await SeedAsync(owner, album);
 
-        Assert.False(result.IsError);
-        Assert.Equal("New Title", result.Value.Title);
-        Assert.Equal("New description", result.Value.Description);
-        Assert.Equal(2025, result.Value.ReleaseYear);
+            var command = new UpdateAlbumCommand(owner.Id, album.Id, "  New Title  ", "New description", 2025, null);
 
-        var stored = await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal("NEW TITLE", stored.NormalizedTitle);
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ValidPictureIntent_UpdatesPictureAndPublishesSourceEvent()
-    {
-        storageService
-            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
-            .Returns(new ObjectMetaData("image/webp", 1024));
+            Assert.False(result.IsError);
+            Assert.Equal("New Title", result.Value.Title);
+            Assert.Equal("New description", result.Value.Description);
+            Assert.Equal(2025, result.Value.ReleaseYear);
 
-        var owner = TestEntities.User();
-        var album = TestEntities.Album(owner.Id, title: "Old Title");
-        var intent = TestEntities.UploadIntent(owner.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.AlbumPicture, objectName: "new-cover.webp");
-        await SeedAsync(owner, album, intent);
+            var stored = await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal("NEW TITLE", stored.NormalizedTitle);
+        }
 
-        var command = new UpdateAlbumCommand(owner.Id, album.Id, "Old Title", null, null, intent.Id);
+        [Fact]
+        public async Task Handle_ValidPictureIntent_UpdatesPictureAndPublishesSourceEvent()
+        {
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 1024));
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id, title: "Old Title");
+            var intent = TestEntities.UploadIntent(owner.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.AlbumPicture, objectName: "new-cover.webp");
+            await SeedAsync(owner, album, intent);
 
-        Assert.False(result.IsError);
-        var stored = await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal("new-cover.webp", stored.Pictures?.OriginalName);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.UpdateAlbumPictureSourceEvent>(), Arg.Any<CancellationToken>());
-    }
+            var command = new UpdateAlbumCommand(owner.Id, album.Id, "Old Title", null, null, intent.Id);
 
-    [Fact]
-    public async Task Handle_AlbumMissing_ReturnsNotFound()
-    {
-        var command = new UpdateAlbumCommand(1, Guid.NewGuid(), "Title", null, null, null);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            var stored = await Database.Albums.FindAsync([album.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal("new-cover.webp", stored.Pictures?.OriginalName);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.UpdateAlbumPictureSourceEvent>(), Arg.Any<CancellationToken>());
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_AlbumMissing_ReturnsNotFound()
+        {
+            var command = new UpdateAlbumCommand(1, Guid.NewGuid(), "Title", null, null, null);
 
-    [Fact]
-    public async Task Handle_NotOwner_ReturnsForbidden()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var stranger = TestEntities.User(2, "stranger");
-        var album = TestEntities.Album(owner.Id);
-        await SeedAsync(owner, stranger, album);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new UpdateAlbumCommand(stranger.Id, album.Id, "Hijacked", null, null, null);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsForbidden()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, stranger, album);
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+            var command = new UpdateAlbumCommand(stranger.Id, album.Id, "Hijacked", null, null, null);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
     }
 }

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

@@ -2,29 +2,30 @@ using Musify.Application.Configuration;
 using Musify.Application.Tests.TestSupport;
 using Xunit;
 
-namespace Musify.Application.Tests.Configuration;
-
-public sealed class GetPlaybackPublicConfigTests
+namespace Musify.Application.Tests.Configuration
 {
-    [Fact]
-    public async Task Handle_ReflectsPlaybackConfiguration()
+    public sealed class GetPlaybackPublicConfigTests
     {
-        var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
-        var handler = new GetPlaybackPublicConfigQueryHandler(playback);
+        [Fact]
+        public async Task Handle_ReflectsPlaybackConfiguration()
+        {
+            var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
+            var handler = new GetPlaybackPublicConfigQueryHandler(playback);
 
-        var response = await handler.Handle(new GetPlaybackPublicConfigQuery(), TestContext.Current.CancellationToken);
+            var response = await handler.Handle(new GetPlaybackPublicConfigQuery(), TestContext.Current.CancellationToken);
 
-        Assert.True(response.AllowAnonymousListening);
-        Assert.Equal(30, response.AnonymousFragmentSeconds);
-    }
+            Assert.True(response.AllowAnonymousListening);
+            Assert.Equal(30, response.AnonymousFragmentSeconds);
+        }
 
-    [Fact]
-    public async Task Handle_DefaultsToDisabled()
-    {
-        var handler = new GetPlaybackPublicConfigQueryHandler(TestConfigurations.Playback());
+        [Fact]
+        public async Task Handle_DefaultsToDisabled()
+        {
+            var handler = new GetPlaybackPublicConfigQueryHandler(TestConfigurations.Playback());
 
-        var response = await handler.Handle(new GetPlaybackPublicConfigQuery(), TestContext.Current.CancellationToken);
+            var response = await handler.Handle(new GetPlaybackPublicConfigQuery(), TestContext.Current.CancellationToken);
 
-        Assert.False(response.AllowAnonymousListening);
+            Assert.False(response.AllowAnonymousListening);
+        }
     }
 }

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

@@ -1,50 +1,51 @@
 using Musify.Application.Configuration;
 using Xunit;
 
-namespace Musify.Application.Tests.Configuration;
-
-public sealed class PicturesConfigurationTests
+namespace Musify.Application.Tests.Configuration
 {
-    [Fact]
-    public void AlbumRoutes_BuildTheSameKeysAsBefore()
+    public sealed class PicturesConfigurationTests
     {
-        var routes = new AlbumConfiguration().Routes;
+        [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"));
+            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));
     }
-
-    [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

@@ -3,30 +3,31 @@ using Musify.Application.Genres.Responses;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.Genres;
-
-public sealed class GetAvailableGenresQueryHandlerTests
+namespace Musify.Application.Tests.Genres
 {
-    private static async Task<IReadOnlyList<AvailableGenreResponse>> RunAsync() =>
-        await new GetAvailableGenresQueryHandler().Handle(new GetAvailableGenresQuery(), TestContext.Current.CancellationToken);
-
-    [Fact]
-    public async Task Handle_ReturnsEveryGenre()
+    public sealed class GetAvailableGenresQueryHandlerTests
     {
-        var result = await RunAsync();
+        private static async Task<IReadOnlyList<AvailableGenreResponse>> RunAsync() =>
+            await new GetAvailableGenresQueryHandler().Handle(new GetAvailableGenresQuery(), TestContext.Current.CancellationToken);
 
-        Assert.Equal(Enum.GetValues<Genre>(), result.Select(r => r.Genre));
-    }
+        [Fact]
+        public async Task Handle_ReturnsEveryGenre()
+        {
+            var result = await RunAsync();
 
-    [Fact]
-    public async Task Handle_ListsIncompatibleGenresSymmetrically()
-    {
-        var result = await RunAsync();
+            Assert.Equal(Enum.GetValues<Genre>(), result.Select(r => r.Genre));
+        }
 
-        var metal = result.Single(r => r.Genre == Genre.Metal);
-        var lofi = result.Single(r => r.Genre == Genre.Lofi);
-        Assert.Contains(Genre.Lofi, metal.IncompatibleWith);
-        Assert.Contains(Genre.Metal, lofi.IncompatibleWith);
-        Assert.Empty(result.Single(r => r.Genre == Genre.Pop).IncompatibleWith);
+        [Fact]
+        public async Task Handle_ListsIncompatibleGenresSymmetrically()
+        {
+            var result = await RunAsync();
+
+            var metal = result.Single(r => r.Genre == Genre.Metal);
+            var lofi = result.Single(r => r.Genre == Genre.Lofi);
+            Assert.Contains(Genre.Lofi, metal.IncompatibleWith);
+            Assert.Contains(Genre.Metal, lofi.IncompatibleWith);
+            Assert.Empty(result.Single(r => r.Genre == Genre.Pop).IncompatibleWith);
+        }
     }
 }

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

@@ -3,35 +3,36 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.Genres;
-
-public sealed class GetGenresQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Genres
 {
-    private GetGenresQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_NoTracks_ReturnsEmpty()
+    public sealed class GetGenresQueryHandlerTests : HandlerTestBase
     {
-        var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
+        private GetGenresQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_NoTracks_ReturnsEmpty()
+        {
+            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
+
+            Assert.Empty(result);
+        }
+
+        [Fact]
+        public async Task Handle_ReturnsOnlyGenresInUse_MostPopulatedFirst()
+        {
+            var owner = TestEntities.User();
+            var rockA = TestEntities.Track(owner, "Rock A", tags: [Genre.Rock]);
+            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);
+
+            var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
+
+            Assert.Equal(
+                [(Genre.Rock, 2), (Genre.Jazz, 1), (Genre.Indie, 1)],
+                result.Select(r => (r.Genre, r.TrackCount)));
+        }
 
-        Assert.Empty(result);
     }
-
-    [Fact]
-    public async Task Handle_ReturnsOnlyGenresInUse_MostPopulatedFirst()
-    {
-        var owner = TestEntities.User();
-        var rockA = TestEntities.Track(owner, "Rock A", tags: [Genre.Rock]);
-        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);
-
-        var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
-
-        Assert.Equal(
-            [(Genre.Rock, 2), (Genre.Jazz, 1), (Genre.Indie, 1)],
-            result.Select(r => (r.Genre, r.TrackCount)));
-    }
-
 }

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

@@ -3,46 +3,47 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Likes;
-
-public sealed class GetLikedTracksQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Likes
 {
-    private GetLikedTracksQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_MultipleLikes_ReturnsMostRecentFirst()
+    public sealed class GetLikedTracksQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var older = TestEntities.Track(owner, "Older like");
-        var newer = TestEntities.Track(owner, "Newer like");
-        await SeedAsync(
-            owner, older, newer,
-            new TrackLike { UserId = owner.Id, TrackId = older.Id, CreatedAt = DateTime.UtcNow.AddMinutes(-10) },
-            new TrackLike { UserId = owner.Id, TrackId = newer.Id, CreatedAt = DateTime.UtcNow });
+        private GetLikedTracksQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
-        Assert.Equal(["Newer like", "Older like"], result.Items.Select(track => track.Title));
-    }
+        [Fact]
+        public async Task Handle_MultipleLikes_ReturnsMostRecentFirst()
+        {
+            var owner = TestEntities.User();
+            var older = TestEntities.Track(owner, "Older like");
+            var newer = TestEntities.Track(owner, "Newer like");
+            await SeedAsync(
+                owner, older, newer,
+                new TrackLike { UserId = owner.Id, TrackId = older.Id, CreatedAt = DateTime.UtcNow.AddMinutes(-10) },
+                new TrackLike { UserId = owner.Id, TrackId = newer.Id, CreatedAt = DateTime.UtcNow });
 
-    [Fact]
-    public async Task Handle_NoLikes_ReturnsEmpty()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner);
+            var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
+            Assert.Equal(["Newer like", "Older like"], result.Items.Select(track => track.Title));
+        }
 
-        var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
-        Assert.Empty(result.Items);
-    }
+        [Fact]
+        public async Task Handle_NoLikes_ReturnsEmpty()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
 
-    [Fact]
-    public async Task Handle_OtherUsersLikes_AreExcluded()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var stranger = TestEntities.User(2, "stranger");
-        var track = TestEntities.Track(owner);
-        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.Empty(result.Items);
+        }
 
-        var result = await CreateHandler().Handle(new GetLikedTracksQuery(owner.Id, 1, 10), TestContext.Current.CancellationToken);
-        Assert.Empty(result.Items);
+        [Fact]
+        public async Task Handle_OtherUsersLikes_AreExcluded()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var track = TestEntities.Track(owner);
+            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.Empty(result.Items);
+        }
     }
 }

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

@@ -4,52 +4,53 @@ using Musify.Application.Likes;
 using Musify.Application.Tests.TestSupport;
 using Xunit;
 
-namespace Musify.Application.Tests.Likes;
-
-public sealed class ToggleTrackLikeCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Likes
 {
-    private ToggleTrackLikeCommandHandler CreateHandler() =>
-        new(Database, NoOpLogger<ToggleTrackLikeCommandHandler>());
-
-    [Fact]
-    public async Task Handle_TrackNotLiked_LikesIt()
+    public sealed class ToggleTrackLikeCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
+        private ToggleTrackLikeCommandHandler CreateHandler() =>
+            new(Database, NoOpLogger<ToggleTrackLikeCommandHandler>());
 
-        var result = await CreateHandler().Handle(
-            new ToggleTrackLikeCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackNotLiked_LikesIt()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
 
-        Assert.False(result.IsError);
-        Assert.True(result.Value);
-        Assert.Single(await Database.TrackLikes.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackAlreadyLiked_UnlikesIt()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track, new Musify.Domain.Entities.TrackLike { UserId = owner.Id, TrackId = track.Id });
+            Assert.False(result.IsError);
+            Assert.True(result.Value);
+            Assert.Single(await Database.TrackLikes.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(
-            new ToggleTrackLikeCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackAlreadyLiked_UnlikesIt()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track, new Musify.Domain.Entities.TrackLike { UserId = owner.Id, TrackId = track.Id });
 
-        Assert.False(result.IsError);
-        Assert.False(result.Value);
-        Assert.Empty(await Database.TrackLikes.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackMissing_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner);
+            Assert.False(result.IsError);
+            Assert.False(result.Value);
+            Assert.Empty(await Database.TrackLikes.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(
-            new ToggleTrackLikeCommand(owner.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackMissing_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+            var result = await CreateHandler().Handle(
+                new ToggleTrackLikeCommand(owner.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -4,78 +4,79 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.Mixes;
-
-public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Mixes
 {
-    private GenerateMixesForUserCommandHandler CreateHandler() => new(
-        Database, TestConfigurations.Mix(), NoOpLogger<GenerateMixesForUserCommandHandler>());
-
-    [Fact]
-    public async Task Handle_NoTracks_DoesNotCreateAnyMix()
+    public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+        private GenerateMixesForUserCommandHandler CreateHandler() => new(
+            Database, TestConfigurations.Mix(), NoOpLogger<GenerateMixesForUserCommandHandler>());
 
-        await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
-        Assert.Empty(await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken));
-    }
+        [Fact]
+        public async Task Handle_NoTracks_DoesNotCreateAnyMix()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-    [Fact]
-    public async Task Handle_AllTracksAlreadyListenedTo_CreatesOnlyTheDailyMix()
-    {
-        var user = TestEntities.User();
-        var track = TestEntities.Track(user);
-        await SeedAsync(
-            user, track,
-            TestEntities.ListeningHistory(user.Id, track.Id));
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
+            Assert.Empty(await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
-        var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
-        Assert.Single(mixes);
-        Assert.Equal(MixKind.Daily, mixes[0].Kind);
-    }
+        [Fact]
+        public async Task Handle_AllTracksAlreadyListenedTo_CreatesOnlyTheDailyMix()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id));
 
-    [Fact]
-    public async Task Handle_UnheardTracksInLibrary_CreatesDiscoveryAndDailyMixes_AndReplacesPreviousMixes()
-    {
-        var user = TestEntities.User();
-        var listenedTrack = TestEntities.Track(user, "Listened Track");
-        var unheardTrack = TestEntities.Track(user, "Unheard Track");
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
+            var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
+            Assert.Single(mixes);
+            Assert.Equal(MixKind.Daily, mixes[0].Kind);
+        }
 
-        var staleMix = TestEntities.Mix(user.Id, MixKind.Daily);
-        var staleItem = TestEntities.MixItem(staleMix.Id, listenedTrack.Id);
+        [Fact]
+        public async Task Handle_UnheardTracksInLibrary_CreatesDiscoveryAndDailyMixes_AndReplacesPreviousMixes()
+        {
+            var user = TestEntities.User();
+            var listenedTrack = TestEntities.Track(user, "Listened Track");
+            var unheardTrack = TestEntities.Track(user, "Unheard Track");
 
-        await SeedAsync(
-            user, listenedTrack, unheardTrack, staleMix, staleItem,
-            TestEntities.ListeningHistory(user.Id, listenedTrack.Id));
+            var staleMix = TestEntities.Mix(user.Id, MixKind.Daily);
+            var staleItem = TestEntities.MixItem(staleMix.Id, listenedTrack.Id);
 
-        await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
-        var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
-        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));
+            await SeedAsync(
+                user, listenedTrack, unheardTrack, staleMix, staleItem,
+                TestEntities.ListeningHistory(user.Id, listenedTrack.Id));
 
-        var discoveryMix = mixes.Single(mix => mix.Kind == MixKind.Discovery);
-        var discoveryItems = await Database.MixItems
-            .Where(item => item.MixId == discoveryMix.Id)
-            .ToListAsync(TestContext.Current.CancellationToken);
-        Assert.All(discoveryItems, item => Assert.Equal(unheardTrack.Id, item.TrackId));
-    }
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
+            var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
+            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));
 
-    [Fact]
-    public async Task Handle_TrackWithOnlyUncountedListens_IsTreatedAsUnheard()
-    {
-        var user = TestEntities.User();
-        var skipped = TestEntities.Track(user, "Only skipped");
-        await SeedAsync(
-            user, skipped,
-            TestEntities.ListeningHistory(user.Id, skipped.Id, playedSeconds: 3, isCounted: false));
+            var discoveryMix = mixes.Single(mix => mix.Kind == MixKind.Discovery);
+            var discoveryItems = await Database.MixItems
+                .Where(item => item.MixId == discoveryMix.Id)
+                .ToListAsync(TestContext.Current.CancellationToken);
+            Assert.All(discoveryItems, item => Assert.Equal(unheardTrack.Id, item.TrackId));
+        }
 
-        await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackWithOnlyUncountedListens_IsTreatedAsUnheard()
+        {
+            var user = TestEntities.User();
+            var skipped = TestEntities.Track(user, "Only skipped");
+            await SeedAsync(
+                user, skipped,
+                TestEntities.ListeningHistory(user.Id, skipped.Id, playedSeconds: 3, isCounted: false));
 
-        var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
-        Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
+            await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
+
+            var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
+            Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
+        }
     }
 }

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

@@ -4,47 +4,48 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.Mixes;
-
-public sealed class GetMixByIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Mixes
 {
-    private GetMixByIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_OwnedMix_ReturnsItWithOrderedItems()
+    public sealed class GetMixByIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var firstTrack = TestEntities.Track(owner, "First");
-        var secondTrack = TestEntities.Track(owner, "Second");
-        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);
+        private GetMixByIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetMixByIdQuery(owner.Id, mix.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_OwnedMix_ReturnsItWithOrderedItems()
+        {
+            var owner = TestEntities.User();
+            var firstTrack = TestEntities.Track(owner, "First");
+            var secondTrack = TestEntities.Track(owner, "Second");
+            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);
 
-        Assert.False(result.IsError);
-        Assert.Equal(MixKind.Daily, result.Value.Kind);
-        Assert.Equal(["First", "Second"], result.Value.Items.Select(item => item.Title));
-    }
+            var result = await CreateHandler().Handle(new GetMixByIdQuery(owner.Id, mix.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_MixMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetMixByIdQuery(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal(MixKind.Daily, result.Value.Kind);
+            Assert.Equal(["First", "Second"], result.Value.Items.Select(item => item.Title));
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_MixMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetMixByIdQuery(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_MixBelongsToAnotherUser_ReturnsNotFound()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var mix = TestEntities.Mix(owner.Id);
-        await SeedAsync(owner, mix);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetMixByIdQuery(2, mix.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_MixBelongsToAnotherUser_ReturnsNotFound()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var mix = TestEntities.Mix(owner.Id);
+            await SeedAsync(owner, mix);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+            var result = await CreateHandler().Handle(new GetMixByIdQuery(2, mix.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -3,33 +3,34 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.Mixes;
-
-public sealed class GetMixesByUserIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Mixes
 {
-    private GetMixesByUserIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ReturnsOnlyThatUsersMixesOrderedByPosition()
+    public sealed class GetMixesByUserIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User(1, "owner");
-        var other = TestEntities.User(2, "other");
-        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);
+        private GetMixesByUserIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
-        Assert.Equal([MixKind.Discovery, MixKind.Daily], result.Select(mix => mix.Kind));
-    }
+        [Fact]
+        public async Task Handle_ReturnsOnlyThatUsersMixesOrderedByPosition()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var other = TestEntities.User(2, "other");
+            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);
 
-    [Fact]
-    public async Task Handle_NoMixes_ReturnsEmptyList()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner);
+            var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+            Assert.Equal([MixKind.Discovery, MixKind.Daily], result.Select(mix => mix.Kind));
+        }
 
-        var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
-        Assert.Empty(result);
+        [Fact]
+        public async Task Handle_NoMixes_ReturnsEmptyList()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
+
+            var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+            Assert.Empty(result);
+        }
     }
 }

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

@@ -5,100 +5,101 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.Pictures;
-
-public sealed class GetCoverQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Pictures
 {
-    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)
+    public sealed class GetCoverQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
+        private GetCoverQueryHandler CreateHandler() => new(
+            Database,
+            TestConfigurations.Storage("covers-bucket"),
+            TestConfigurations.Track(),
+            TestConfigurations.Album(),
+            TestConfigurations.PlayList());
 
-        var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Track, track.Id, size), TestContext.Current.CancellationToken);
+        [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);
 
-        Assert.False(result.IsError);
-        Assert.Equal("covers-bucket", result.Value.Bucket);
-        Assert.EndsWith(expectedFileName, result.Value.Key);
-        Assert.Equal("image/webp", result.Value.ContentType);
-    }
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Track, track.Id, size), TestContext.Current.CancellationToken);
 
-    [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);
+            Assert.False(result.IsError);
+            Assert.Equal("covers-bucket", result.Value.Bucket);
+            Assert.EndsWith(expectedFileName, result.Value.Key);
+            Assert.Equal("image/webp", result.Value.ContentType);
+        }
 
-        var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id, size), TestContext.Current.CancellationToken);
+        [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);
 
-        Assert.False(result.IsError);
-        Assert.EndsWith(expectedFileName, result.Value.Key);
-    }
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id, size), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ProcessedPlayList_ReturnsRequestedSize()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        await SeedAsync(owner, playList);
+            Assert.False(result.IsError);
+            Assert.EndsWith(expectedFileName, result.Value.Key);
+        }
 
-        var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.PlayList, playList.Id, PictureSize.Large), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ProcessedPlayList_ReturnsRequestedSize()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
-        Assert.EndsWith("large.webp", result.Value.Key);
-    }
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.PlayList, playList.Id, PictureSize.Large), TestContext.Current.CancellationToken);
 
-    [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.False(result.IsError);
+            Assert.EndsWith("large.webp", result.Value.Key);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [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);
 
-    [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);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id, PictureSize.Small), TestContext.Current.CancellationToken);
+        [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);
 
-        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);
-    }
+            var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id, PictureSize.Small), TestContext.Current.CancellationToken);
 
-    [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);
+            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);
+        }
 
-        var result = await CreateHandler().Handle(new GetCoverQuery(CoverOwner.Album, album.Id), TestContext.Current.CancellationToken);
+        [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);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+            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/AddTracksToPlayListCommandHandlerTests.cs

@@ -5,125 +5,126 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class AddTracksToPlayListCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private AddTracksToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToPlayListCommandHandler>());
-
-    [Fact]
-    public async Task Handle_FirstTrack_AddsItAtPositionZero()
+    public sealed class AddTracksToPlayListCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, playList, track);
+        private AddTracksToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToPlayListCommandHandler>());
 
-        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_FirstTrack_AddsItAtPositionZero()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, playList, track);
 
-        Assert.False(result.IsError);
-        var link = Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
-        Assert.Equal(0, link.Position);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayListAlreadyHasTracks_AppendsAtNextPosition()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        var existingTrack = TestEntities.Track(owner, "Existing");
-        var newTrack = TestEntities.Track(owner, "New");
-        await SeedAsync(
-            owner, playList, existingTrack, newTrack,
-            new PlayListHasTrack { PlayListId = playList.Id, TrackId = existingTrack.Id, Position = 0 });
+            Assert.False(result.IsError);
+            var link = Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
+            Assert.Equal(0, link.Position);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [newTrack.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PlayListAlreadyHasTracks_AppendsAtNextPosition()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var existingTrack = TestEntities.Track(owner, "Existing");
+            var newTrack = TestEntities.Track(owner, "New");
+            await SeedAsync(
+                owner, playList, existingTrack, newTrack,
+                new PlayListHasTrack { PlayListId = playList.Id, TrackId = existingTrack.Id, Position = 0 });
 
-        Assert.False(result.IsError);
-        var newLink = await Database.PlayListHasTracks.SingleAsync(link => link.TrackId == newTrack.Id, TestContext.Current.CancellationToken);
-        Assert.Equal(1, newLink.Position);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [newTrack.Id]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(1, Guid.NewGuid(), [Guid.NewGuid()]), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            var newLink = await Database.PlayListHasTracks.SingleAsync(link => link.TrackId == newTrack.Id, TestContext.Current.CancellationToken);
+            Assert.Equal(1, newLink.Position);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_PlayListMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(1, Guid.NewGuid(), [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    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);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(stranger.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
+        [Fact]
+        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);
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(stranger.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackMissing_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        await SeedAsync(owner, playList);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackMissing_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
 
-    [Fact]
-    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 });
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
+        [Fact]
+        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 });
 
-        Assert.False(result.IsError);
-        Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), 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 });
+            Assert.False(result.IsError);
+            Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await Database.TrySaveChangesAsync(Error.Conflict("Test.Duplicate", "duplicate"), 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 });
 
-        Assert.Equal("Test.Duplicate", result.FirstError.Code);
-    }
+            var result = await Database.TrySaveChangesAsync(Error.Conflict("Test.Duplicate", "duplicate"), TestContext.Current.CancellationToken);
 
-    [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 });
+            Assert.Equal("Test.Duplicate", result.FirstError.Code);
+        }
 
-        var result = await CreateHandler().Handle(
-            new AddTracksToPlayListCommand(owner.Id, playList.Id, [first.Id, existing.Id, second.Id, first.Id]),
-            TestContext.Current.CancellationToken);
+        [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 });
 
-        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));
+            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

@@ -6,106 +6,107 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class CreatePlayListCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private CreatePlayListCommandHandler CreateHandler() => new(
-        eventBus,
-        Database,
-        new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
-        NoOpLogger<CreatePlayListCommandHandler>(),
-        TestConfigurations.PlayList());
-
-    [Fact]
-    public async Task Handle_NoPictureIntent_CreatesPlayListWithoutPictures()
+    public sealed class CreatePlayListCommandHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        var command = new CreatePlayListCommand(user.Id, "My Playlist", "A description", PictureIntentId: null);
+        private CreatePlayListCommandHandler CreateHandler() => new(
+            eventBus,
+            Database,
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
+            NoOpLogger<CreatePlayListCommandHandler>(),
+            TestConfigurations.PlayList());
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NoPictureIntent_CreatesPlayListWithoutPictures()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        Assert.False(result.IsError);
-        Assert.Equal("My Playlist", result.Value.Name);
-        Assert.Null(result.Value.SmallImageKeyName);
-        await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
-    }
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", "A description", PictureIntentId: null);
 
-    [Fact]
-    public async Task Handle_WithValidPictureIntent_PublishesResourcesEvent()
-    {
-        storageService
-            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
-            .Returns(new ObjectMetaData("image/webp", 1024));
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var user = TestEntities.User();
-        var intent = TestEntities.UploadIntent(user.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.PlayListPicture, objectName: "cover.webp");
-        await SeedAsync(user, intent);
+            Assert.False(result.IsError);
+            Assert.Equal("My Playlist", result.Value.Name);
+            Assert.Null(result.Value.SmallImageKeyName);
+            await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
+        }
 
-        var command = new CreatePlayListCommand(user.Id, "My Playlist", null, intent.Id);
+        [Fact]
+        public async Task Handle_WithValidPictureIntent_PublishesResourcesEvent()
+        {
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 1024));
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var user = TestEntities.User();
+            var intent = TestEntities.UploadIntent(user.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.PlayListPicture, objectName: "cover.webp");
+            await SeedAsync(user, intent);
 
-        Assert.False(result.IsError);
-        var stored = await Database.PlayLists.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal("cover.webp", stored.Pictures?.OriginalName);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
-    }
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, intent.Id);
 
-    [Fact]
-    public async Task Handle_NoVisibilitySpecified_DefaultsToPrivate()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null);
+            Assert.False(result.IsError);
+            var stored = await Database.PlayLists.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal("cover.webp", stored.Pictures?.OriginalName);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NoVisibilitySpecified_DefaultsToPrivate()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        Assert.False(result.IsError);
-        Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Private, result.Value.Visibility);
-    }
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null);
 
-    [Fact]
-    public async Task Handle_PublicVisibility_PersistsIt()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null, Visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
+            Assert.False(result.IsError);
+            Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Private, result.Value.Visibility);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PublicVisibility_PersistsIt()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        Assert.False(result.IsError);
-        Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
-    }
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, PictureIntentId: null, Visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var command = new CreatePlayListCommand(404, "Orphan Playlist", null, null);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        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(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var command = new CreatePlayListCommand(404, "Orphan Playlist", null, null);
 
-    [Fact]
-    public async Task Handle_PictureIntentNotFound_ReturnsError()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new CreatePlayListCommand(user.Id, "My Playlist", null, Guid.NewGuid());
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PictureIntentNotFound_ReturnsError()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        Assert.True(result.IsError);
+            var command = new CreatePlayListCommand(user.Id, "My Playlist", null, Guid.NewGuid());
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.True(result.IsError);
+        }
     }
 }

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

@@ -6,48 +6,49 @@ using Musify.Domain.ValueObjects;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class DeletePlayListCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-
-    private DeletePlayListCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeletePlayListCommandHandler>());
-
-    [Fact]
-    public async Task Handle_Owner_MarksPlayListAsRemoving()
+    public sealed class DeletePlayListCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        await SeedAsync(owner, playList);
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
 
-        var result = await CreateHandler().Handle(new DeletePlayListCommand(owner.Id, playList.Id), TestContext.Current.CancellationToken);
+        private DeletePlayListCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeletePlayListCommandHandler>());
 
-        Assert.False(result.IsError);
-        var stored = await Database.PlayLists.FindAsync([playList.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.DeletePlayListEvent>(), Arg.Any<CancellationToken>());
-    }
+        [Fact]
+        public async Task Handle_Owner_MarksPlayListAsRemoving()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new DeletePlayListCommand(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new DeletePlayListCommand(owner.Id, playList.Id), TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            Assert.False(result.IsError);
+            var stored = await Database.PlayLists.FindAsync([playList.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.DeletePlayListEvent>(), Arg.Any<CancellationToken>());
+        }
 
-    [Fact]
-    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);
+        [Fact]
+        public async Task Handle_PlayListMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new DeletePlayListCommand(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-        var result = await CreateHandler().Handle(new DeletePlayListCommand(stranger.Id, playList.Id), TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        [Fact]
+        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 DeletePlayListCommand(stranger.Id, playList.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
     }
 }

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

@@ -4,81 +4,82 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class GetPlayListByIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private GetPlayListByIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ExistingPlayList_ReturnsItWithCoverTrackIds()
+    public sealed class GetPlayListByIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        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 });
+        private GetPlayListByIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ExistingPlayList_ReturnsItWithCoverTrackIds()
+        {
+            var owner = TestEntities.User();
+            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 });
 
-        Assert.False(result.IsError);
-        Assert.Equal(playList.Name, result.Value.Name);
-        Assert.Equal([track.Id], result.Value.CoverTrackIds);
-    }
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetPlayListByIdQuery(Guid.NewGuid()), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal(playList.Name, result.Value.Name);
+            Assert.Equal([track.Id], result.Value.CoverTrackIds);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_PlayListMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PrivatePlayList_RequestedByOwner_ReturnsIt()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
-        await SeedAsync(owner, playList);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PrivatePlayList_RequestedByOwner_ReturnsIt()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
-    }
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, owner.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PrivatePlayList_RequestedByStranger_ReturnsNotFound()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var stranger = TestEntities.User(2, "stranger");
-        var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
-        await SeedAsync(owner, stranger, playList);
+            Assert.False(result.IsError);
+        }
 
-        var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, stranger.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PrivatePlayList_RequestedByStranger_ReturnsNotFound()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
+            await SeedAsync(owner, stranger, playList);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, stranger.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PrivatePlayList_RequestedAnonymously_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
-        await SeedAsync(owner, playList);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PrivatePlayList_RequestedAnonymously_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Private);
+            await SeedAsync(owner, playList);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PublicPlayList_RequestedAnonymously_ReturnsIt()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
-        await SeedAsync(owner, playList);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PublicPlayList_RequestedAnonymously_ReturnsIt()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
+            var result = await CreateHandler().Handle(new GetPlayListByIdQuery(playList.Id, RequestingUserId: null), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+        }
     }
 }

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

@@ -5,59 +5,60 @@ using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class GetPlayListTracksQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private GetPlayListTracksQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_TracksOrderedByPosition_ReturnsThemInOrder()
+    public sealed class GetPlayListTracksQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        var second = TestEntities.Track(owner, "Second");
-        var first = TestEntities.Track(owner, "First");
-        await SeedAsync(
-            owner, playList, second, first,
-            new PlayListHasTrack { PlayListId = playList.Id, TrackId = second.Id, Position = 1 },
-            new PlayListHasTrack { PlayListId = playList.Id, TrackId = first.Id, Position = 0 });
+        private GetPlayListTracksQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TracksOrderedByPosition_ReturnsThemInOrder()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var second = TestEntities.Track(owner, "Second");
+            var first = TestEntities.Track(owner, "First");
+            await SeedAsync(
+                owner, playList, second, first,
+                new PlayListHasTrack { PlayListId = playList.Id, TrackId = second.Id, Position = 1 },
+                new PlayListHasTrack { PlayListId = playList.Id, TrackId = first.Id, Position = 0 });
 
-        Assert.False(result.IsError);
-        Assert.Equal(["First", "Second"], result.Value.Items.Select(track => track.Title));
-    }
+            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetPlayListTracksQuery(Guid.NewGuid(), PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal(["First", "Second"], result.Value.Items.Select(track => track.Title));
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_PlayListMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(Guid.NewGuid(), PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PrivatePlayListOfAnotherUser_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, visibility: PlayListVisibility.Private);
-        await SeedAsync(owner, playList);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: 999), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PrivatePlayListOfAnotherUser_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: PlayListVisibility.Private);
+            await SeedAsync(owner, playList);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: 999), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PrivatePlayListOfViewer_ReturnsTracks()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, visibility: PlayListVisibility.Private);
-        await SeedAsync(owner, playList);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PrivatePlayListOfViewer_ReturnsTracks()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: PlayListVisibility.Private);
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
+            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

@@ -3,63 +3,64 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class GetPlayListsByUserIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private GetPlayListsByUserIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ReturnsOnlyActivePlayListsForThatUser()
+    public sealed class GetPlayListsByUserIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User(1, "owner");
-        var other = TestEntities.User(2, "other");
-        await SeedAsync(
-            owner, other,
-            TestEntities.PlayList(owner.Id, "Mine"),
-            TestEntities.PlayList(owner.Id, "Being removed", lifeCycleStatus: LifeCycleStatus.Removing),
-            TestEntities.PlayList(other.Id, "Theirs"));
+        private GetPlayListsByUserIdQueryHandler CreateHandler() => new(Database);
 
-        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_ReturnsOnlyActivePlayListsForThatUser()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var other = TestEntities.User(2, "other");
+            await SeedAsync(
+                owner, other,
+                TestEntities.PlayList(owner.Id, "Mine"),
+                TestEntities.PlayList(owner.Id, "Being removed", lifeCycleStatus: LifeCycleStatus.Removing),
+                TestEntities.PlayList(other.Id, "Theirs"));
 
-    [Fact]
-    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));
+            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);
+        }
 
-        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_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));
 
-    [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: 999), TestContext.Current.CancellationToken);
+            var playList = Assert.Single(result.Items);
+            Assert.Equal("Public one", playList.Name);
+        }
 
-        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_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));
 
-    [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: null, PageNumber: 1, PageSize: 10, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+            Assert.Equal(2, result.Items.Count);
+        }
 
-        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);
+        [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, ViewerId: owner.Id), TestContext.Current.CancellationToken);
+            var playList = Assert.Single(result.Items);
+            Assert.Equal("Road Trip", playList.Name);
+        }
     }
 }

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

@@ -4,78 +4,79 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class RemoveTrackFromPlayListCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private RemoveTrackFromPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<RemoveTrackFromPlayListCommandHandler>());
-
-    [Fact]
-    public async Task Handle_TrackInPlayList_RemovesTheLink()
+    public sealed class RemoveTrackFromPlayListCommandHandlerTests : HandlerTestBase
     {
-        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 });
+        private RemoveTrackFromPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<RemoveTrackFromPlayListCommandHandler>());
 
-        var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackInPlayList_RemovesTheLink()
+        {
+            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 });
 
-        Assert.False(result.IsError);
-        Assert.Empty(Database.PlayListHasTracks);
-    }
+            var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Empty(Database.PlayListHasTracks);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_PlayListMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    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);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(stranger.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        [Fact]
+        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);
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(stranger.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackNotLinked_ReturnsNotFound()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        await SeedAsync(owner, playList);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(owner.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackNotLinked_ReturnsNotFound()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(owner.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [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 });
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new RemoveTrackFromPlayListCommand(owner.Id, playList.Id, second.Id), TestContext.Current.CancellationToken);
+        [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 });
 
-        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));
+            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

@@ -8,70 +8,71 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class RequestPlayListPictureUploadCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private RequestPlayListPictureUploadCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
+    public sealed class RequestPlayListPictureUploadCommandHandlerTests : HandlerTestBase
     {
-        storageService
-            .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");
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
+        private RequestPlayListPictureUploadCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
+        {
+            storageService
+                .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");
 
-        return new RequestPlayListPictureUploadCommandHandler(
-            new UploadIntentIssuer(
-                Database,
-                storageService,
-                new UploadIntentValidator(Database, storageService, config),
-                TestConfigurations.Storage(),
-                config,
-                NoOpLogger<UploadIntentIssuer>()),
-            TestConfigurations.PlayList());
-    }
+            var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
 
-    [Fact]
-    public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+            return new RequestPlayListPictureUploadCommandHandler(
+                new UploadIntentIssuer(
+                    Database,
+                    storageService,
+                    new UploadIntentValidator(Database, storageService, config),
+                    TestConfigurations.Storage(),
+                    config,
+                    NoOpLogger<UploadIntentIssuer>()),
+                TestConfigurations.PlayList());
+        }
 
-        var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp");
+        [Fact]
+        public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp");
 
-        Assert.False(result.IsError);
-        Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.UploadUrl);
-        Assert.Single(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var command = new RequestPlayListPictureUploadCommand(404, "webp", "image/webp");
+            Assert.False(result.IsError);
+            Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.UploadUrl);
+            Assert.Single(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var command = new RequestPlayListPictureUploadCommand(404, "webp", "image/webp");
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserOverByteQuota_ReturnsValidationErrorAndCreatesNoIntent()
-    {
-        var config = TestConfigurations.UploadIntent();
-        config.MaxActiveUploadBytesPerUser = 100;
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var user = TestEntities.User();
-        await SeedAsync(user);
+        [Fact]
+        public async Task Handle_UserOverByteQuota_ReturnsValidationErrorAndCreatesNoIntent()
+        {
+            var config = TestConfigurations.UploadIntent();
+            config.MaxActiveUploadBytesPerUser = 100;
 
-        var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp", ExpectedSizeBytes: 1_000_000);
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        var result = await CreateHandler(config).Handle(command, TestContext.Current.CancellationToken);
+            var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp", ExpectedSizeBytes: 1_000_000);
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-        Assert.Empty(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+            var result = await CreateHandler(config).Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+            Assert.Empty(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+        }
     }
 }

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

@@ -6,128 +6,129 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class UpdatePlayListCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private UpdatePlayListCommandHandler CreateHandler() => new(
-        eventBus,
-        Database,
-        new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
-        NoOpLogger<UpdatePlayListCommandHandler>(),
-        TestConfigurations.PlayList());
-
-    [Fact]
-    public async Task Handle_Owner_RenamesPlayList()
+    public sealed class UpdatePlayListCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, "Old Name");
-        await SeedAsync(owner, playList);
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        var command = new UpdatePlayListCommand(owner.Id, playList.Id, "New Name", null, null);
+        private UpdatePlayListCommandHandler CreateHandler() => new(
+            eventBus,
+            Database,
+            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
+            NoOpLogger<UpdatePlayListCommandHandler>(),
+            TestConfigurations.PlayList());
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_Owner_RenamesPlayList()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, "Old Name");
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
-        Assert.Equal("New Name", result.Value.Name);
-    }
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, "New Name", null, null);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var command = new UpdatePlayListCommand(1, Guid.NewGuid(), "New Name", null, null);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal("New Name", result.Value.Name);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_PlayListMissing_ReturnsNotFound()
+        {
+            var command = new UpdatePlayListCommand(1, Guid.NewGuid(), "New Name", null, null);
 
-    [Fact]
-    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(command, TestContext.Current.CancellationToken);
 
-        var command = new UpdatePlayListCommand(stranger.Id, playList.Id, "Hijacked", null, null);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        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);
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+            var command = new UpdatePlayListCommand(stranger.Id, playList.Id, "Hijacked", null, null);
 
-    [Fact]
-    public async Task Handle_NewVisibility_UpdatesIt()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        await SeedAsync(owner, playList);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, null, Musify.Domain.ValueObjects.PlayListVisibility.Public);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NewVisibility_UpdatesIt()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
-        Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
-    }
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, null, Musify.Domain.ValueObjects.PlayListVisibility.Public);
 
-    [Fact]
-    public async Task Handle_NoVisibilitySpecified_LeavesItUnchanged()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
-        await SeedAsync(owner, playList);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new UpdatePlayListCommand(owner.Id, playList.Id, "New Name", null, null);
+            Assert.False(result.IsError);
+            Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NoVisibilitySpecified_LeavesItUnchanged()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, visibility: Musify.Domain.ValueObjects.PlayListVisibility.Public);
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
-        Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
-    }
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, "New Name", null, null);
 
-    [Fact]
-    public async Task Handle_BlankName_LeavesItUnchangedAndBlankDescriptionClearsIt()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id, "Original Name", "Original description");
-        await SeedAsync(owner, playList);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var command = new UpdatePlayListCommand(owner.Id, playList.Id, "   ", "   ", null);
+            Assert.False(result.IsError);
+            Assert.Equal(Musify.Domain.ValueObjects.PlayListVisibility.Public, result.Value.Visibility);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_BlankName_LeavesItUnchangedAndBlankDescriptionClearsIt()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id, "Original Name", "Original description");
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
-        Assert.Equal("Original Name", result.Value.Name);
-        Assert.Null(result.Value.Description);
-    }
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, "   ", "   ", null);
 
-    [Fact]
-    public async Task Handle_PlayListWithoutPictures_ValidPictureIntent_SetsPictureAndPublishesSourceEvent()
-    {
-        storageService
-            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
-            .Returns(new ObjectMetaData("image/webp", 1024));
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        playList.Pictures = null;
-        var intent = TestEntities.UploadIntent(owner.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.PlayListPicture, objectName: "new-cover.webp");
-        await SeedAsync(owner, playList, intent);
+            Assert.False(result.IsError);
+            Assert.Equal("Original Name", result.Value.Name);
+            Assert.Null(result.Value.Description);
+        }
 
-        var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, intent.Id);
+        [Fact]
+        public async Task Handle_PlayListWithoutPictures_ValidPictureIntent_SetsPictureAndPublishesSourceEvent()
+        {
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 1024));
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            playList.Pictures = null;
+            var intent = TestEntities.UploadIntent(owner.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.PlayListPicture, objectName: "new-cover.webp");
+            await SeedAsync(owner, playList, intent);
 
-        Assert.False(result.IsError);
-        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);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.UpdatePlayListPictureSourceEvent>(), Arg.Any<CancellationToken>());
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, intent.Id);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            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);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.UpdatePlayListPictureSourceEvent>(), Arg.Any<CancellationToken>());
+        }
     }
 }

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

@@ -5,59 +5,60 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Services;
-
-public sealed class TrackStreamIssuerTests
+namespace Musify.Application.Tests.Services
 {
-    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(
-        ticketService,
-        TestConfigurations.Track(),
-        TestConfigurations.StreamGateway("https://stream.musify.test/"),
-        playback ?? TestConfigurations.Playback());
-
-    [Fact]
-    public void Issue_BuildsManifestUrlAndCarriesTheListenId()
+    public sealed class TrackStreamIssuerTests
     {
-        var listenId = Guid.NewGuid();
+        private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
 
-        var response = CreateIssuer().Issue("folder-42", userId: 7, listenId);
+        public TrackStreamIssuerTests() =>
+            ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("signed-token", 120));
 
-        Assert.Equal("signed-token", response.Ticket);
-        Assert.Equal(120, response.ExpiresInSeconds);
-        Assert.Equal(listenId, response.ListenId);
-        Assert.Equal("https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a", response.ManifestUrl);
-    }
+        private TrackStreamIssuer CreateIssuer(PlaybackConfiguration? playback = null) => new(
+            ticketService,
+            TestConfigurations.Track(),
+            TestConfigurations.StreamGateway("https://stream.musify.test/"),
+            playback ?? TestConfigurations.Playback());
 
-    [Fact]
-    public void Issue_PassesTheProcessedAudioKeyPrefixToTheTicketService()
-    {
-        CreateIssuer().Issue("folder-42", userId: 1, listenId: null);
+        [Fact]
+        public void Issue_BuildsManifestUrlAndCarriesTheListenId()
+        {
+            var listenId = Guid.NewGuid();
 
-        ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
-    }
+            var response = CreateIssuer().Issue("folder-42", userId: 7, listenId);
 
-    [Fact]
-    public void Issue_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
-    {
-        var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
+            Assert.Equal("signed-token", response.Ticket);
+            Assert.Equal(120, response.ExpiresInSeconds);
+            Assert.Equal(listenId, response.ListenId);
+            Assert.Equal("https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a", response.ManifestUrl);
+        }
 
-        CreateIssuer(playback).Issue("folder-42", userId: null, listenId: null);
+        [Fact]
+        public void Issue_PassesTheProcessedAudioKeyPrefixToTheTicketService()
+        {
+            CreateIssuer().Issue("folder-42", userId: 1, listenId: null);
 
-        ticketService.Received(1).IssueTicket(null, "Tracks/ProcessedAudios/folder-42/", 30L * playback.EstimatedAudioBytesPerSecond);
-    }
+            ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
+        }
 
-    [Fact]
-    public void Issue_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
-    {
-        var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
+        [Fact]
+        public void Issue_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
+        {
+            var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
 
-        CreateIssuer(playback).Issue("folder-42", userId: 1, listenId: null);
+            CreateIssuer(playback).Issue("folder-42", userId: null, listenId: null);
 
-        ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
+            ticketService.Received(1).IssueTicket(null, "Tracks/ProcessedAudios/folder-42/", 30L * playback.EstimatedAudioBytesPerSecond);
+        }
+
+        [Fact]
+        public void Issue_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
+        {
+            var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
+
+            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

@@ -7,152 +7,153 @@ using Musify.Domain.ValueObjects;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Services;
-
-public sealed class UploadIntentValidatorTests : HandlerTestBase
+namespace Musify.Application.Tests.Services
 {
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-    private readonly Domain.Entities.User owner = TestEntities.User();
-
-    private UploadIntentValidator CreateValidator(UploadIntentConfiguration? config = null) =>
-        new(Database, storageService, config ?? TestConfigurations.UploadIntent());
-
-    [Fact]
-    public async Task ValidateAndLoadAsync_UploadedObjectWithinLimits_ReturnsTheIntent()
+    public sealed class UploadIntentValidatorTests : HandlerTestBase
     {
-        storageService
-            .HeadObjectAsync("bucket", "temp/object.webp", Arg.Any<CancellationToken>())
-            .Returns(new ObjectMetaData("image/webp", 2048));
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
+        private readonly Domain.Entities.User owner = TestEntities.User();
 
-        var intent = TestEntities.UploadIntent(owner.Id, bucket: "bucket", key: "temp/object.webp");
-        await SeedAsync(owner, intent);
+        private UploadIntentValidator CreateValidator(UploadIntentConfiguration? config = null) =>
+            new(Database, storageService, config ?? TestConfigurations.UploadIntent());
 
-        var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task ValidateAndLoadAsync_UploadedObjectWithinLimits_ReturnsTheIntent()
+        {
+            storageService
+                .HeadObjectAsync("bucket", "temp/object.webp", Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 2048));
 
-        Assert.False(result.IsError);
-        Assert.Equal(intent.Id, result.Value.Id);
-    }
+            var intent = TestEntities.UploadIntent(owner.Id, bucket: "bucket", key: "temp/object.webp");
+            await SeedAsync(owner, intent);
 
-    [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);
 
-        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);
+        }
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task ValidateAndLoadAsync_IntentIssuedForAnotherPurpose_ReturnsValidationError()
+        {
+            var intent = TestEntities.UploadIntent(owner.Id, UploadIntentPurpose.TrackAudio);
+            await SeedAsync(owner, intent);
 
-    [Fact]
-    public async Task ValidateAndLoadAsync_IntentMissing_ReturnsNotFound()
-    {
-        var result = await CreateValidator().ValidateAndLoadAsync(Guid.NewGuid(), owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
 
-    [Fact]
-    public async Task ValidateAndLoadAsync_IntentBelongsToAnotherUser_ReturnsNotFound()
-    {
-        var stranger = TestEntities.User(2, "stranger");
-        var intent = TestEntities.UploadIntent(owner.Id);
-        await SeedAsync(owner, stranger, intent);
+        [Fact]
+        public async Task ValidateAndLoadAsync_IntentMissing_ReturnsNotFound()
+        {
+            var result = await CreateValidator().ValidateAndLoadAsync(Guid.NewGuid(), owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
-        var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, stranger.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task ValidateAndLoadAsync_IntentBelongsToAnotherUser_ReturnsNotFound()
+        {
+            var stranger = TestEntities.User(2, "stranger");
+            var intent = TestEntities.UploadIntent(owner.Id);
+            await SeedAsync(owner, stranger, intent);
 
-    [Fact]
-    public async Task ValidateAndLoadAsync_AlreadyConsumed_ReturnsConflict()
-    {
-        var intent = TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Consumed);
-        await SeedAsync(owner, intent);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, stranger.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
-        var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task ValidateAndLoadAsync_AlreadyConsumed_ReturnsConflict()
+        {
+            var intent = TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Consumed);
+            await SeedAsync(owner, intent);
 
-    [Fact]
-    public async Task ValidateAndLoadAsync_PastExpiry_ReturnsValidationError()
-    {
-        var intent = TestEntities.UploadIntent(owner.Id, expiresAt: DateTime.UtcNow.AddMinutes(-1));
-        await SeedAsync(owner, intent);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
-        var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task ValidateAndLoadAsync_PastExpiry_ReturnsValidationError()
+        {
+            var intent = TestEntities.UploadIntent(owner.Id, expiresAt: DateTime.UtcNow.AddMinutes(-1));
+            await SeedAsync(owner, intent);
 
-    [Fact]
-    public async Task ValidateAndLoadAsync_ObjectNeverUploaded_ReturnsNotFound()
-    {
-        storageService
-            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
-            .Returns((ObjectMetaData?)null);
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
-        var intent = TestEntities.UploadIntent(owner.Id);
-        await SeedAsync(owner, intent);
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
 
-        var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task ValidateAndLoadAsync_ObjectNeverUploaded_ReturnsNotFound()
+        {
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns((ObjectMetaData?)null);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var intent = TestEntities.UploadIntent(owner.Id);
+            await SeedAsync(owner, intent);
 
-    [Fact]
-    public async Task ValidateAndLoadAsync_UploadedObjectExceedsMaxSize_ReturnsValidationError()
-    {
-        var config = TestConfigurations.UploadIntent();
-        config.MaxUploadBytes = 1024;
+            var result = await CreateValidator().ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
-        storageService
-            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
-            .Returns(new ObjectMetaData("image/webp", 2048));
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var intent = TestEntities.UploadIntent(owner.Id);
-        await SeedAsync(owner, intent);
+        [Fact]
+        public async Task ValidateAndLoadAsync_UploadedObjectExceedsMaxSize_ReturnsValidationError()
+        {
+            var config = TestConfigurations.UploadIntent();
+            config.MaxUploadBytes = 1024;
 
-        var result = await CreateValidator(config).ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 2048));
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
+            var intent = TestEntities.UploadIntent(owner.Id);
+            await SeedAsync(owner, intent);
 
-    [Fact]
-    public async Task CheckQuotaAsync_WithinLimits_ReturnsSuccess()
-    {
-        await SeedAsync(owner);
+            var result = await CreateValidator(config).ValidateAndLoadAsync(intent.Id, owner.Id, UploadIntentPurpose.TrackPicture, TestContext.Current.CancellationToken);
 
-        var result = await CreateValidator().CheckQuotaAsync(owner.Id, requiredBytes: 1024, requiredIntentCount: 1, TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
 
-        Assert.False(result.IsError);
-    }
+        [Fact]
+        public async Task CheckQuotaAsync_WithinLimits_ReturnsSuccess()
+        {
+            await SeedAsync(owner);
 
-    [Fact]
-    public async Task CheckQuotaAsync_TooManyActiveIntents_ReturnsValidationError()
-    {
-        var config = TestConfigurations.UploadIntent();
-        config.MaxActiveUploadIntentsPerUser = 1;
-        await SeedAsync(owner, TestEntities.UploadIntent(owner.Id));
+            var result = await CreateValidator().CheckQuotaAsync(owner.Id, requiredBytes: 1024, requiredIntentCount: 1, TestContext.Current.CancellationToken);
 
-        var result = await CreateValidator(config).CheckQuotaAsync(owner.Id, requiredBytes: 1, requiredIntentCount: 1, TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+        }
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task CheckQuotaAsync_TooManyActiveIntents_ReturnsValidationError()
+        {
+            var config = TestConfigurations.UploadIntent();
+            config.MaxActiveUploadIntentsPerUser = 1;
+            await SeedAsync(owner, TestEntities.UploadIntent(owner.Id));
 
-    [Fact]
-    public async Task CheckQuotaAsync_ExpiredOrConsumedIntentsDoNotCountTowardsTheLimit()
-    {
-        var config = TestConfigurations.UploadIntent();
-        config.MaxActiveUploadIntentsPerUser = 1;
-        await SeedAsync(
-            owner,
-            TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Expired),
-            TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Consumed));
+            var result = await CreateValidator(config).CheckQuotaAsync(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);
+        }
 
-        Assert.False(result.IsError);
+        [Fact]
+        public async Task CheckQuotaAsync_ExpiredOrConsumedIntentsDoNotCountTowardsTheLimit()
+        {
+            var config = TestConfigurations.UploadIntent();
+            config.MaxActiveUploadIntentsPerUser = 1;
+            await SeedAsync(
+                owner,
+                TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Expired),
+                TestEntities.UploadIntent(owner.Id, status: UploadIntentStatus.Consumed));
+
+            var result = await CreateValidator(config).CheckQuotaAsync(owner.Id, requiredBytes: 1, requiredIntentCount: 1, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+        }
     }
 }

backend/Tests/Musify.Application.Tests/Shared/StorageKeyTests.cs

@@ -1,40 +1,41 @@
 using Musify.Application.Shared;
 using Xunit;
 
-namespace Musify.Application.Tests.Shared;
-
-public sealed class StorageKeyTests
+namespace Musify.Application.Tests.Shared
 {
-    [Fact]
-    public void Combine_MultipleSegments_JoinsThemWithForwardSlashes()
+    public sealed class StorageKeyTests
     {
-        var key = StorageKey.Combine("Tracks", "SmallPictures", "cover.webp");
+        [Fact]
+        public void Combine_MultipleSegments_JoinsThemWithForwardSlashes()
+        {
+            var key = StorageKey.Combine("Tracks", "SmallPictures", "cover.webp");
 
-        Assert.Equal("Tracks/SmallPictures/cover.webp", key);
-    }
+            Assert.Equal("Tracks/SmallPictures/cover.webp", key);
+        }
 
-    [Fact]
-    public void Combine_SegmentsWithSurroundingSlashesAndWhitespace_TrimsThem()
-    {
-        var key = StorageKey.Combine(" Tracks/ ", "/SmallPictures/", "cover.webp");
+        [Fact]
+        public void Combine_SegmentsWithSurroundingSlashesAndWhitespace_TrimsThem()
+        {
+            var key = StorageKey.Combine(" Tracks/ ", "/SmallPictures/", "cover.webp");
 
-        Assert.Equal("Tracks/SmallPictures/cover.webp", key);
-    }
+            Assert.Equal("Tracks/SmallPictures/cover.webp", key);
+        }
 
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("   ")]
-    public void Combine_BlankSegment_IsSkipped(string? blank)
-    {
-        var key = StorageKey.Combine("Tracks", blank!, "cover.webp");
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("   ")]
+        public void Combine_BlankSegment_IsSkipped(string? blank)
+        {
+            var key = StorageKey.Combine("Tracks", blank!, "cover.webp");
 
-        Assert.Equal("Tracks/cover.webp", key);
-    }
+            Assert.Equal("Tracks/cover.webp", key);
+        }
 
-    [Fact]
-    public void Combine_NoSegments_ReturnsEmptyString()
-    {
-        Assert.Equal(string.Empty, StorageKey.Combine());
+        [Fact]
+        public void Combine_NoSegments_ReturnsEmptyString()
+        {
+            Assert.Equal(string.Empty, StorageKey.Combine());
+        }
     }
 }

backend/Tests/Musify.Application.Tests/Shared/TrackApplicationResponseTests.cs

@@ -2,31 +2,32 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks.Responses;
 using Xunit;
 
-namespace Musify.Application.Tests.Shared;
-
-public sealed class TrackApplicationResponseTests
+namespace Musify.Application.Tests.Shared
 {
-    [Fact]
-    public void FromEntity_UsesOwnerNameAsArtist()
+    public sealed class TrackApplicationResponseTests
     {
-        var owner = TestEntities.User(1, "The Owner");
-        var track = TestEntities.Track(owner);
+        [Fact]
+        public void FromEntity_UsesOwnerNameAsArtist()
+        {
+            var owner = TestEntities.User(1, "The Owner");
+            var track = TestEntities.Track(owner);
 
-        var response = TrackApplicationResponse.FromEntity(track, listensCount: 3);
+            var response = TrackApplicationResponse.FromEntity(track, listensCount: 3);
 
-        Assert.Equal("The Owner", response.Artist);
-        Assert.Equal(owner.Id, response.OwnerUserId);
-        Assert.Equal(3, response.ListensCount);
-        Assert.False(response.IsExplicit);
-    }
+            Assert.Equal("The Owner", response.Artist);
+            Assert.Equal(owner.Id, response.OwnerUserId);
+            Assert.Equal(3, response.ListensCount);
+            Assert.False(response.IsExplicit);
+        }
 
-    [Fact]
-    public void FromEntity_CopiesExplicitFlag()
-    {
-        var track = TestEntities.Track(TestEntities.User(), isExplicit: true);
+        [Fact]
+        public void FromEntity_CopiesExplicitFlag()
+        {
+            var track = TestEntities.Track(TestEntities.User(), isExplicit: true);
 
-        var response = TrackApplicationResponse.FromEntity(track, listensCount: 0);
+            var response = TrackApplicationResponse.FromEntity(track, listensCount: 0);
 
-        Assert.True(response.IsExplicit);
+            Assert.True(response.IsExplicit);
+        }
     }
 }

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

@@ -2,29 +2,30 @@ using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Xunit;
 
-namespace Musify.Application.Tests.TestSupport;
-
-public abstract class HandlerTestBase : IAsyncLifetime
+namespace Musify.Application.Tests.TestSupport
 {
-    private TestDatabase database = null!;
-
-    protected TestDatabase Database => database;
-
-    public async ValueTask InitializeAsync() => database = await TestDatabase.CreateAsync();
-
-    public ValueTask DisposeAsync()
+    public abstract class HandlerTestBase : IAsyncLifetime
     {
-        GC.SuppressFinalize(this);
-        return database.DisposeAsync();
-    }
+        private TestDatabase database = null!;
 
-    protected static ILogger<T> NoOpLogger<T>() => NullLogger<T>.Instance;
+        protected TestDatabase Database => database;
 
-    protected async Task SeedAsync(params object[] entities)
-    {
-        foreach (var entity in entities)
-            Database.Add(entity);
+        public async ValueTask InitializeAsync() => database = await TestDatabase.CreateAsync();
 
-        await Database.SaveChangesAsync(CancellationToken.None);
+        public ValueTask DisposeAsync()
+        {
+            GC.SuppressFinalize(this);
+            return database.DisposeAsync();
+        }
+
+        protected static ILogger<T> NoOpLogger<T>() => NullLogger<T>.Instance;
+
+        protected async Task SeedAsync(params object[] entities)
+        {
+            foreach (var entity in entities)
+                Database.Add(entity);
+
+            await Database.SaveChangesAsync(CancellationToken.None);
+        }
     }
 }

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

@@ -1,25 +1,26 @@
 using Musify.Application.Configuration;
 
-namespace Musify.Application.Tests.TestSupport;
-
-public static class TestConfigurations
+namespace Musify.Application.Tests.TestSupport
 {
-    public static ApplicationStorageConfiguration Storage(string bucket = "test-bucket") =>
-        new() { Bucket = bucket };
+    public static class TestConfigurations
+    {
+        public static ApplicationStorageConfiguration Storage(string bucket = "test-bucket") =>
+            new() { Bucket = bucket };
 
-    public static TrackConfiguration Track() => new();
+        public static TrackConfiguration Track() => new();
 
-    public static PlayListConfiguration PlayList() => new();
+        public static PlayListConfiguration PlayList() => new();
 
-    public static AlbumConfiguration Album() => new();
+        public static AlbumConfiguration Album() => new();
 
-    public static MixConfiguration Mix() => new();
+        public static MixConfiguration Mix() => new();
 
-    public static UploadIntentConfiguration UploadIntent() => new();
+        public static UploadIntentConfiguration UploadIntent() => new();
 
-    public static StreamGatewayConfiguration StreamGateway(string publicBaseUrl = "https://stream.musify.test") =>
-        new() { PublicBaseUrl = publicBaseUrl };
+        public static StreamGatewayConfiguration StreamGateway(string publicBaseUrl = "https://stream.musify.test") =>
+            new() { PublicBaseUrl = publicBaseUrl };
 
-    public static PlaybackConfiguration Playback(bool allowAnonymousListening = false, int anonymousFragmentSeconds = 0) =>
-        new() { AllowAnonymousListening = allowAnonymousListening, AnonymousFragmentSeconds = anonymousFragmentSeconds };
+        public static PlaybackConfiguration Playback(bool allowAnonymousListening = false, int anonymousFragmentSeconds = 0) =>
+            new() { AllowAnonymousListening = allowAnonymousListening, AnonymousFragmentSeconds = anonymousFragmentSeconds };
+    }
 }

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

@@ -5,96 +5,97 @@ using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 using Musify.Infrastructure.Persistence;
 
-namespace Musify.Application.Tests.TestSupport;
-
-public sealed class TestDatabase : DbContext, IDatabase
+namespace Musify.Application.Tests.TestSupport
 {
-    private readonly SqliteConnection connection;
-
-    private TestDatabase(SqliteConnection connection, DbContextOptions<TestDatabase> options)
-        : base(options)
+    public sealed class TestDatabase : DbContext, IDatabase
     {
-        this.connection = connection;
-    }
+        private readonly SqliteConnection connection;
 
-    public static async Task<TestDatabase> CreateAsync()
-    {
-        var connection = new SqliteConnection("Filename=:memory:");
-        await connection.OpenAsync();
-
-        var options = new DbContextOptionsBuilder<TestDatabase>()
-            .UseSqlite(connection)
-            .Options;
-
-        var database = new TestDatabase(connection, options);
-        await database.Database.EnsureCreatedAsync();
-        return database;
-    }
-
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-    {
-        base.OnModelCreating(modelBuilder);
-
-        ModelConfiguration.Apply(modelBuilder);
-    }
-
-    public DbSet<User> Users => Set<User>();
-
-    public DbSet<PlayList> PlayLists => Set<PlayList>();
-
-    public DbSet<Album> Albums => Set<Album>();
-
-    public DbSet<AlbumHasTrack> AlbumHasTracks => Set<AlbumHasTrack>();
-
-    public DbSet<Track> Tracks => Set<Track>();
-
-    public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
-
-    public DbSet<Mix> Mixes => Set<Mix>();
-
-    public DbSet<MixItem> MixItems => Set<MixItem>();
-
-    public DbSet<UploadIntent> UploadIntents => Set<UploadIntent>();
-
-    public DbSet<ListeningHistory> ListeningHistories => Set<ListeningHistory>();
-
-    public DbSet<TrackLike> TrackLikes => Set<TrackLike>();
-
-    public DbSet<TrackTag> TrackTags => Set<TrackTag>();
-
-    public DbSet<UserFollow> UserFollows => Set<UserFollow>();
-
-    public async Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken)
-    {
-        var transaction = await Database.BeginTransactionAsync(isolationLevel, cancellationToken);
-        return new SqliteDatabaseTransaction(transaction);
-    }
-
-    public async Task<ErrorOr<Success>> TrySaveChangesAsync(Error onUniqueViolation, CancellationToken cancellationToken)
-    {
-        try
+        private TestDatabase(SqliteConnection connection, DbContextOptions<TestDatabase> options)
+            : base(options)
         {
-            await SaveChangesAsync(cancellationToken);
-            return Result.Success;
+            this.connection = connection;
         }
-        catch (DbUpdateException exception) when (exception.InnerException is SqliteException { SqliteErrorCode: 19 })
+
+        public static async Task<TestDatabase> CreateAsync()
         {
-            return onUniqueViolation;
+            var connection = new SqliteConnection("Filename=:memory:");
+            await connection.OpenAsync();
+
+            var options = new DbContextOptionsBuilder<TestDatabase>()
+                .UseSqlite(connection)
+                .Options;
+
+            var database = new TestDatabase(connection, options);
+            await database.Database.EnsureCreatedAsync();
+            return database;
         }
-    }
 
-    public override async ValueTask DisposeAsync()
-    {
-        await base.DisposeAsync();
-        await connection.DisposeAsync();
-    }
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            base.OnModelCreating(modelBuilder);
 
-    private sealed class SqliteDatabaseTransaction(Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction inner)
-        : IDatabaseTransaction
-    {
-        public Task CommitAsync(CancellationToken cancellationToken = default) =>
-            inner.CommitAsync(cancellationToken);
+            ModelConfiguration.Apply(modelBuilder);
+        }
 
-        public ValueTask DisposeAsync() => inner.DisposeAsync();
+        public DbSet<User> Users => Set<User>();
+
+        public DbSet<PlayList> PlayLists => Set<PlayList>();
+
+        public DbSet<Album> Albums => Set<Album>();
+
+        public DbSet<AlbumHasTrack> AlbumHasTracks => Set<AlbumHasTrack>();
+
+        public DbSet<Track> Tracks => Set<Track>();
+
+        public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
+
+        public DbSet<Mix> Mixes => Set<Mix>();
+
+        public DbSet<MixItem> MixItems => Set<MixItem>();
+
+        public DbSet<UploadIntent> UploadIntents => Set<UploadIntent>();
+
+        public DbSet<ListeningHistory> ListeningHistories => Set<ListeningHistory>();
+
+        public DbSet<TrackLike> TrackLikes => Set<TrackLike>();
+
+        public DbSet<TrackTag> TrackTags => Set<TrackTag>();
+
+        public DbSet<UserFollow> UserFollows => Set<UserFollow>();
+
+        public async Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken)
+        {
+            var transaction = await Database.BeginTransactionAsync(isolationLevel, cancellationToken);
+            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();
+            await connection.DisposeAsync();
+        }
+
+        private sealed class SqliteDatabaseTransaction(Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction inner)
+            : IDatabaseTransaction
+        {
+            public Task CommitAsync(CancellationToken cancellationToken = default) =>
+                inner.CommitAsync(cancellationToken);
+
+            public ValueTask DisposeAsync() => inner.DisposeAsync();
+        }
     }
 }

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

@@ -1,191 +1,192 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Application.Tests.TestSupport;
-
-public static class TestEntities
+namespace Musify.Application.Tests.TestSupport
 {
-    public static User User(
-        long id = 1,
-        string name = "test-user",
-        string? firstName = "Test",
-        string? secondName = "User",
-        string? profilePictureUrl = null) =>
-        new()
+    public static class TestEntities
+    {
+        public static User User(
+            long id = 1,
+            string name = "test-user",
+            string? firstName = "Test",
+            string? secondName = "User",
+            string? profilePictureUrl = null) =>
+            new()
+            {
+                Id = id,
+                Name = name,
+                NormalizedName = name.ToUpperInvariant(),
+                FirstName = firstName,
+                SecondName = secondName,
+                ProfilePictureUrl = profilePictureUrl
+            };
+
+        public static TrackPictures ProcessedPictures() => new()
         {
-            Id = id,
-            Name = name,
-            NormalizedName = name.ToUpperInvariant(),
-            FirstName = firstName,
-            SecondName = secondName,
-            ProfilePictureUrl = profilePictureUrl
+            OriginalName = "original.webp",
+            SmallName = "small.webp",
+            MediumName = "medium.webp",
+            LargeName = "large.webp",
+            ProcessingStatus = ProcessingStatus.Completed
         };
 
-    public static TrackPictures ProcessedPictures() => new()
-    {
-        OriginalName = "original.webp",
-        SmallName = "small.webp",
-        MediumName = "medium.webp",
-        LargeName = "large.webp",
-        ProcessingStatus = ProcessingStatus.Completed
-    };
-
-    public static TrackPictures PendingPictures() => new()
-    {
-        OriginalName = "original.webp",
-        ProcessingStatus = ProcessingStatus.Pending
-    };
-
-    public static TrackAudio ProcessedAudio(string folderName = "audio-folder") => new()
-    {
-        OriginalName = "original.mp3",
-        FolderName = folderName,
-        TranscodeStatus = ProcessingStatus.Completed
-    };
-
-    public static TrackAudio PendingAudio() => new()
-    {
-        OriginalName = "original.mp3",
-        TranscodeStatus = ProcessingStatus.Pending
-    };
-
-    public static Track Track(
-        User owner,
-        string title = "Test Track",
-        double durationSeconds = 180,
-        TrackPictures? pictures = null,
-        TrackAudio? audio = null,
-        LifeCycleStatus lifeCycleStatus = LifeCycleStatus.Active,
-        IEnumerable<Genre>? tags = null,
-        bool isExplicit = false)
-    {
-        var track = new Track
+        public static TrackPictures PendingPictures() => new()
         {
-            Title = title,
-            NormalizedTitle = title.ToUpperInvariant(),
-            DurationSeconds = durationSeconds,
-            LifeCycleStatus = lifeCycleStatus,
-            IsExplicit = isExplicit,
-            OwnerUserId = owner.Id,
-            Owner = owner,
-            Pictures = pictures ?? ProcessedPictures(),
-            Audio = audio ?? ProcessedAudio()
+            OriginalName = "original.webp",
+            ProcessingStatus = ProcessingStatus.Pending
         };
 
-        track.Tags = (tags ?? [Genre.Pop])
-            .Select(tag => new TrackTag { TrackId = track.Id, Tag = tag })
-            .ToList();
+        public static TrackAudio ProcessedAudio(string folderName = "audio-folder") => new()
+        {
+            OriginalName = "original.mp3",
+            FolderName = folderName,
+            TranscodeStatus = ProcessingStatus.Completed
+        };
 
-        return track;
+        public static TrackAudio PendingAudio() => new()
+        {
+            OriginalName = "original.mp3",
+            TranscodeStatus = ProcessingStatus.Pending
+        };
+
+        public static Track Track(
+            User owner,
+            string title = "Test Track",
+            double durationSeconds = 180,
+            TrackPictures? pictures = null,
+            TrackAudio? audio = null,
+            LifeCycleStatus lifeCycleStatus = LifeCycleStatus.Active,
+            IEnumerable<Genre>? tags = null,
+            bool isExplicit = false)
+        {
+            var track = new Track
+            {
+                Title = title,
+                NormalizedTitle = title.ToUpperInvariant(),
+                DurationSeconds = durationSeconds,
+                LifeCycleStatus = lifeCycleStatus,
+                IsExplicit = isExplicit,
+                OwnerUserId = owner.Id,
+                Owner = owner,
+                Pictures = pictures ?? ProcessedPictures(),
+                Audio = audio ?? ProcessedAudio()
+            };
+
+            track.Tags = (tags ?? [Genre.Pop])
+                .Select(tag => new TrackTag { TrackId = track.Id, Tag = tag })
+                .ToList();
+
+            return track;
+        }
+
+        public static EntityPictures PlayListPictures() => new()
+        {
+            OriginalName = "original.webp",
+            SmallName = "small.webp",
+            MediumName = "medium.webp",
+            LargeName = "large.webp"
+        };
+
+        public static PlayList PlayList(
+            long userId,
+            string name = "Test Playlist",
+            string? description = null,
+            EntityPictures? pictures = null,
+            LifeCycleStatus lifeCycleStatus = LifeCycleStatus.Active,
+            PlayListVisibility visibility = PlayListVisibility.Private) =>
+            new()
+            {
+                OwnerUserId = userId,
+                Name = name,
+                NormalizedName = name.ToUpperInvariant(),
+                Description = description,
+                Pictures = pictures ?? PlayListPictures(),
+                LifeCycleStatus = lifeCycleStatus,
+                Visibility = visibility
+            };
+
+        public static EntityPictures AlbumPictures() => new()
+        {
+            OriginalName = "original.webp",
+            SmallName = "small.webp",
+            MediumName = "medium.webp",
+            LargeName = "large.webp"
+        };
+
+        public static Album Album(
+            long ownerUserId,
+            string title = "Test Album",
+            string? description = null,
+            int? releaseYear = 2024,
+            EntityPictures? pictures = null) =>
+            new()
+            {
+                Title = title,
+                NormalizedTitle = title.ToUpperInvariant(),
+                Description = description,
+                ReleaseYear = releaseYear,
+                OwnerUserId = ownerUserId,
+                Pictures = pictures ?? AlbumPictures()
+            };
+
+        public static UploadIntent UploadIntent(
+            long userId,
+            UploadIntentPurpose purpose = UploadIntentPurpose.TrackPicture,
+            string bucket = "test-bucket",
+            string key = "temp/object.webp",
+            string objectName = "object.webp",
+            string contentType = "image/webp",
+            long? expectedSizeBytes = 1024,
+            UploadIntentStatus status = UploadIntentStatus.Issued,
+            DateTime? expiresAt = null) =>
+            new()
+            {
+                UserId = userId,
+                Bucket = bucket,
+                Key = key,
+                ObjectName = objectName,
+                ContentType = contentType,
+                ExpectedSizeBytes = expectedSizeBytes,
+                Purpose = purpose,
+                Status = status,
+                ExpiresAt = expiresAt ?? DateTime.UtcNow.AddMinutes(5)
+            };
+
+        public static Mix Mix(
+            long userId,
+            MixKind kind = MixKind.Discovery,
+            int position = 0) =>
+            new()
+            {
+                UserId = userId,
+                Kind = kind,
+                Position = position
+            };
+
+        public static MixItem MixItem(
+            Guid mixId,
+            Guid trackId,
+            int position = 0) =>
+            new()
+            {
+                MixId = mixId,
+                Position = position,
+                TrackId = trackId
+            };
+
+        public static ListeningHistory ListeningHistory(
+            long userId,
+            Guid trackId,
+            DateTime? listenedAt = null,
+            double? playedSeconds = null,
+            bool isCounted = true) =>
+            new()
+            {
+                UserId = userId,
+                TrackId = trackId,
+                ListenedAt = listenedAt ?? DateTime.UtcNow,
+                PlayedSeconds = playedSeconds,
+                IsCounted = isCounted
+            };
     }
-
-    public static EntityPictures PlayListPictures() => new()
-    {
-        OriginalName = "original.webp",
-        SmallName = "small.webp",
-        MediumName = "medium.webp",
-        LargeName = "large.webp"
-    };
-
-    public static PlayList PlayList(
-        long userId,
-        string name = "Test Playlist",
-        string? description = null,
-        EntityPictures? pictures = null,
-        LifeCycleStatus lifeCycleStatus = LifeCycleStatus.Active,
-        PlayListVisibility visibility = PlayListVisibility.Private) =>
-        new()
-        {
-            OwnerUserId = userId,
-            Name = name,
-            NormalizedName = name.ToUpperInvariant(),
-            Description = description,
-            Pictures = pictures ?? PlayListPictures(),
-            LifeCycleStatus = lifeCycleStatus,
-            Visibility = visibility
-        };
-
-    public static EntityPictures AlbumPictures() => new()
-    {
-        OriginalName = "original.webp",
-        SmallName = "small.webp",
-        MediumName = "medium.webp",
-        LargeName = "large.webp"
-    };
-
-    public static Album Album(
-        long ownerUserId,
-        string title = "Test Album",
-        string? description = null,
-        int? releaseYear = 2024,
-        EntityPictures? pictures = null) =>
-        new()
-        {
-            Title = title,
-            NormalizedTitle = title.ToUpperInvariant(),
-            Description = description,
-            ReleaseYear = releaseYear,
-            OwnerUserId = ownerUserId,
-            Pictures = pictures ?? AlbumPictures()
-        };
-
-    public static UploadIntent UploadIntent(
-        long userId,
-        UploadIntentPurpose purpose = UploadIntentPurpose.TrackPicture,
-        string bucket = "test-bucket",
-        string key = "temp/object.webp",
-        string objectName = "object.webp",
-        string contentType = "image/webp",
-        long? expectedSizeBytes = 1024,
-        UploadIntentStatus status = UploadIntentStatus.Issued,
-        DateTime? expiresAt = null) =>
-        new()
-        {
-            UserId = userId,
-            Bucket = bucket,
-            Key = key,
-            ObjectName = objectName,
-            ContentType = contentType,
-            ExpectedSizeBytes = expectedSizeBytes,
-            Purpose = purpose,
-            Status = status,
-            ExpiresAt = expiresAt ?? DateTime.UtcNow.AddMinutes(5)
-        };
-
-    public static Mix Mix(
-        long userId,
-        MixKind kind = MixKind.Discovery,
-        int position = 0) =>
-        new()
-        {
-            UserId = userId,
-            Kind = kind,
-            Position = position
-        };
-
-    public static MixItem MixItem(
-        Guid mixId,
-        Guid trackId,
-        int position = 0) =>
-        new()
-        {
-            MixId = mixId,
-            Position = position,
-            TrackId = trackId
-        };
-
-    public static ListeningHistory ListeningHistory(
-        long userId,
-        Guid trackId,
-        DateTime? listenedAt = null,
-        double? playedSeconds = null,
-        bool isCounted = true) =>
-        new()
-        {
-            UserId = userId,
-            TrackId = trackId,
-            ListenedAt = listenedAt ?? DateTime.UtcNow,
-            PlayedSeconds = playedSeconds,
-            IsCounted = isCounted
-        };
 }

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

@@ -8,125 +8,126 @@ using Musify.Domain.ValueObjects;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class CreateTrackCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private CreateTrackCommandHandler CreateHandler()
+    public sealed class CreateTrackCommandHandlerTests : HandlerTestBase
     {
-        storageService
-            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
-            .Returns(new ObjectMetaData("image/webp", 1024));
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        return new CreateTrackCommandHandler(
-            Database,
-            eventBus,
-            new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
-            NoOpLogger<CreateTrackCommandHandler>(),
-            TestConfigurations.Track());
-    }
+        private CreateTrackCommandHandler CreateHandler()
+        {
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 1024));
 
-    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"));
+            return new CreateTrackCommandHandler(
+                Database,
+                eventBus,
+                new UploadIntentValidator(Database, storageService, TestConfigurations.UploadIntent()),
+                NoOpLogger<CreateTrackCommandHandler>(),
+                TestConfigurations.Track());
+        }
 
-    [Fact]
-    public async Task Handle_SameIntentForPictureAndAudio_ReturnsValidationError()
-    {
-        var user = TestEntities.User();
-        var (picture, audio) = SeedIntents(user.Id);
-        await SeedAsync(user, picture, audio);
+        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"));
 
-        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, picture.Id, [Genre.Pop]);
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_SameIntentForPictureAndAudio_ReturnsValidationError()
+        {
+            var user = TestEntities.User();
+            var (picture, audio) = SeedIntents(user.Id);
+            await SeedAsync(user, picture, audio);
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
+            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, picture.Id, [Genre.Pop]);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ValidIntents_CreatesTrackAndPublishesEvent()
-    {
-        var user = TestEntities.User();
-        var (picture, audio) = SeedIntents(user.Id);
-        await SeedAsync(user, picture, audio);
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
 
-        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop, Genre.Rock]);
+        [Fact]
+        public async Task Handle_ValidIntents_CreatesTrackAndPublishesEvent()
+        {
+            var user = TestEntities.User();
+            var (picture, audio) = SeedIntents(user.Id);
+            await SeedAsync(user, picture, audio);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop, Genre.Rock]);
 
-        Assert.False(result.IsError);
-        Assert.Equal("My Song", result.Value.Title);
-        var localResponse = Assert.IsType<TrackApplicationResponse>(result.Value);
-        Assert.Equal(user.Id, localResponse.OwnerUserId);
-        Assert.Equal([Genre.Pop, Genre.Rock], localResponse.Tags);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreateTrackResourcesEvent>(), Arg.Any<CancellationToken>());
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        var stored = await Database.Tracks.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal(ProcessingStatus.Pending, stored.Audio.TranscodeStatus);
-    }
+            Assert.False(result.IsError);
+            Assert.Equal("My Song", result.Value.Title);
+            var localResponse = Assert.IsType<TrackApplicationResponse>(result.Value);
+            Assert.Equal(user.Id, localResponse.OwnerUserId);
+            Assert.Equal([Genre.Pop, Genre.Rock], localResponse.Tags);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreateTrackResourcesEvent>(), Arg.Any<CancellationToken>());
 
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public async Task Handle_StoresExplicitFlag(bool isExplicit)
-    {
-        var user = TestEntities.User();
-        var (picture, audio) = SeedIntents(user.Id);
-        await SeedAsync(user, picture, audio);
+            var stored = await Database.Tracks.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal(ProcessingStatus.Pending, stored.Audio.TranscodeStatus);
+        }
 
-        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop], isExplicit);
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task Handle_StoresExplicitFlag(bool isExplicit)
+        {
+            var user = TestEntities.User();
+            var (picture, audio) = SeedIntents(user.Id);
+            await SeedAsync(user, picture, audio);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop], isExplicit);
 
-        Assert.False(result.IsError);
-        Assert.Equal(isExplicit, result.Value.IsExplicit);
-        var stored = await Database.Tracks.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal(isExplicit, stored.IsExplicit);
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var command = new CreateTrackCommand(404, "Orphan Song", Guid.NewGuid(), Guid.NewGuid(), [Genre.Pop]);
+            Assert.False(result.IsError);
+            Assert.Equal(isExplicit, result.Value.IsExplicit);
+            var stored = await Database.Tracks.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal(isExplicit, stored.IsExplicit);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var command = new CreateTrackCommand(404, "Orphan Song", Guid.NewGuid(), Guid.NewGuid(), [Genre.Pop]);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PictureIntentBelongsToAnotherUser_ReturnsError()
-    {
-        var user = TestEntities.User(1, "user");
-        var otherUser = TestEntities.User(2, "other");
-        var (picture, audio) = SeedIntents(otherUser.Id);
-        await SeedAsync(user, otherUser, picture, audio);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop]);
+        [Fact]
+        public async Task Handle_PictureIntentBelongsToAnotherUser_ReturnsError()
+        {
+            var user = TestEntities.User(1, "user");
+            var otherUser = TestEntities.User(2, "other");
+            var (picture, audio) = SeedIntents(otherUser.Id);
+            await SeedAsync(user, otherUser, picture, audio);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop]);
 
-        Assert.True(result.IsError);
-        await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreateTrackResourcesEvent>(), Arg.Any<CancellationToken>());
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AudioIntentAlreadyConsumed_ReturnsError()
-    {
-        var user = TestEntities.User();
-        var picture = TestEntities.UploadIntent(user.Id, UploadIntentPurpose.TrackPicture, objectName: "cover.webp");
-        var audio = TestEntities.UploadIntent(user.Id, UploadIntentPurpose.TrackAudio, objectName: "song.mp3", status: UploadIntentStatus.Consumed);
-        await SeedAsync(user, picture, audio);
+            Assert.True(result.IsError);
+            await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreateTrackResourcesEvent>(), Arg.Any<CancellationToken>());
+        }
 
-        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop]);
+        [Fact]
+        public async Task Handle_AudioIntentAlreadyConsumed_ReturnsError()
+        {
+            var user = TestEntities.User();
+            var picture = TestEntities.UploadIntent(user.Id, UploadIntentPurpose.TrackPicture, objectName: "cover.webp");
+            var audio = TestEntities.UploadIntent(user.Id, UploadIntentPurpose.TrackAudio, objectName: "song.mp3", status: UploadIntentStatus.Consumed);
+            await SeedAsync(user, picture, audio);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Pop]);
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        }
     }
 }

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

@@ -3,29 +3,30 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class DeleteStaleUncountedListensCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private DeleteStaleUncountedListensCommandHandler CreateHandler() =>
-        new(Database, NoOpLogger<DeleteStaleUncountedListensCommandHandler>());
-
-    [Fact]
-    public async Task Handle_DeletesOnlyOldUncountedListens()
+    public sealed class DeleteStaleUncountedListensCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        var oldUncounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-9), playedSeconds: 2, isCounted: false);
-        var oldCounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-9), playedSeconds: 100);
-        var recentUncounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-2), playedSeconds: 2, isCounted: false);
-        await SeedAsync(owner, track, oldUncounted, oldCounted, recentUncounted);
+        private DeleteStaleUncountedListensCommandHandler CreateHandler() =>
+            new(Database, NoOpLogger<DeleteStaleUncountedListensCommandHandler>());
 
-        var deleted = await CreateHandler().Handle(new DeleteStaleUncountedListensCommand(), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_DeletesOnlyOldUncountedListens()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            var oldUncounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-9), playedSeconds: 2, isCounted: false);
+            var oldCounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-9), playedSeconds: 100);
+            var recentUncounted = TestEntities.ListeningHistory(owner.Id, track.Id, DateTime.UtcNow.AddDays(-2), playedSeconds: 2, isCounted: false);
+            await SeedAsync(owner, track, oldUncounted, oldCounted, recentUncounted);
 
-        Assert.Equal(1, deleted);
-        var remaining = await Database.ListeningHistories.Select(l => l.Id).ToListAsync(TestContext.Current.CancellationToken);
-        Assert.DoesNotContain(oldUncounted.Id, remaining);
-        Assert.Contains(oldCounted.Id, remaining);
-        Assert.Contains(recentUncounted.Id, remaining);
+            var deleted = await CreateHandler().Handle(new DeleteStaleUncountedListensCommand(), TestContext.Current.CancellationToken);
+
+            Assert.Equal(1, deleted);
+            var remaining = await Database.ListeningHistories.Select(l => l.Id).ToListAsync(TestContext.Current.CancellationToken);
+            Assert.DoesNotContain(oldUncounted.Id, remaining);
+            Assert.Contains(oldCounted.Id, remaining);
+            Assert.Contains(recentUncounted.Id, remaining);
+        }
     }
 }

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

@@ -6,60 +6,61 @@ using Musify.Domain.ValueObjects;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class DeleteTrackCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-
-    private DeleteTrackCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeleteTrackCommandHandler>());
-
-    [Fact]
-    public async Task Handle_Owner_MarksTrackAsRemovingAndPublishesEvent()
+    public sealed class DeleteTrackCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
 
-        var result = await CreateHandler().Handle(new DeleteTrackCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
+        private DeleteTrackCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeleteTrackCommandHandler>());
 
-        Assert.False(result.IsError);
-        var stored = await Database.Tracks.FindAsync([track.Id], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.DeleteTrackEvent>(), Arg.Any<CancellationToken>());
-    }
+        [Fact]
+        public async Task Handle_Owner_MarksTrackAsRemovingAndPublishesEvent()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
 
-    [Fact]
-    public async Task Handle_TrackMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new DeleteTrackCommand(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(new DeleteTrackCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            Assert.False(result.IsError);
+            var stored = await Database.Tracks.FindAsync([track.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.DeleteTrackEvent>(), Arg.Any<CancellationToken>());
+        }
 
-    [Fact]
-    public async Task Handle_NotOwner_ReturnsForbidden()
-    {
-        var owner = TestEntities.User(1, "owner");
-        var stranger = TestEntities.User(2, "stranger");
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, stranger, track);
+        [Fact]
+        public async Task Handle_TrackMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new DeleteTrackCommand(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-        var result = await CreateHandler().Handle(new DeleteTrackCommand(stranger.Id, track.Id), TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsForbidden()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, stranger, track);
 
-    [Fact]
-    public async Task Handle_AudioStillProcessing_ReturnsConflict()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner, audio: TestEntities.PendingAudio());
-        await SeedAsync(owner, track);
+            var result = await CreateHandler().Handle(new DeleteTrackCommand(stranger.Id, track.Id), TestContext.Current.CancellationToken);
 
-        var result = await CreateHandler().Handle(new DeleteTrackCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_AudioStillProcessing_ReturnsConflict()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner, audio: TestEntities.PendingAudio());
+            await SeedAsync(owner, track);
+
+            var result = await CreateHandler().Handle(new DeleteTrackCommand(owner.Id, track.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        }
     }
 }

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

@@ -2,37 +2,38 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class GetLastTrackListenedByUserIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private GetLastTrackListenedByUserIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_MultipleListens_ReturnsMostRecentlyListenedTrack()
+    public sealed class GetLastTrackListenedByUserIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var older = TestEntities.Track(owner, "Older listen");
-        var newer = TestEntities.Track(owner, "Newer listen");
-        await SeedAsync(
-            owner, older, newer,
-            TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-10)),
-            TestEntities.ListeningHistory(owner.Id, newer.Id, DateTime.UtcNow));
+        private GetLastTrackListenedByUserIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_MultipleListens_ReturnsMostRecentlyListenedTrack()
+        {
+            var owner = TestEntities.User();
+            var older = TestEntities.Track(owner, "Older listen");
+            var newer = TestEntities.Track(owner, "Newer listen");
+            await SeedAsync(
+                owner, older, newer,
+                TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-10)),
+                TestEntities.ListeningHistory(owner.Id, newer.Id, DateTime.UtcNow));
 
-        Assert.NotNull(result);
-        Assert.Equal("Newer listen", result.Title);
-    }
+            var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NoHistory_ReturnsNull()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner);
+            Assert.NotNull(result);
+            Assert.Equal("Newer listen", result.Title);
+        }
 
-        var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NoHistory_ReturnsNull()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
 
-        Assert.Null(result);
+            var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.Null(result);
+        }
     }
 }

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

@@ -2,53 +2,54 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class GetListeningHistoryQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private GetListeningHistoryQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_MultipleListens_ReturnsDistinctTracksMostRecentFirst()
+    public sealed class GetListeningHistoryQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var older = TestEntities.Track(owner, "Older listen");
-        var newer = TestEntities.Track(owner, "Newer listen");
-        await SeedAsync(
-            owner, older, newer,
-            TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-10)),
-            TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-5)),
-            TestEntities.ListeningHistory(owner.Id, newer.Id, DateTime.UtcNow));
+        private GetListeningHistoryQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetListeningHistoryQuery(owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_MultipleListens_ReturnsDistinctTracksMostRecentFirst()
+        {
+            var owner = TestEntities.User();
+            var older = TestEntities.Track(owner, "Older listen");
+            var newer = TestEntities.Track(owner, "Newer listen");
+            await SeedAsync(
+                owner, older, newer,
+                TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-10)),
+                TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-5)),
+                TestEntities.ListeningHistory(owner.Id, newer.Id, DateTime.UtcNow));
 
-        Assert.Equal(["Newer listen", "Older listen"], result.Select(track => track.Title));
-    }
+            var result = await CreateHandler().Handle(new GetListeningHistoryQuery(owner.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NoHistory_ReturnsEmpty()
-    {
-        var owner = TestEntities.User();
-        await SeedAsync(owner);
+            Assert.Equal(["Newer listen", "Older listen"], result.Select(track => track.Title));
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningHistoryQuery(owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NoHistory_ReturnsEmpty()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner);
 
-        Assert.Empty(result);
-    }
+            var result = await CreateHandler().Handle(new GetListeningHistoryQuery(owner.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UncountedListens_AreIgnored()
-    {
-        var owner = TestEntities.User();
-        var counted = TestEntities.Track(owner, "Counted");
-        var skipped = TestEntities.Track(owner, "Skipped");
-        await SeedAsync(
-            owner, counted, skipped,
-            TestEntities.ListeningHistory(owner.Id, counted.Id, DateTime.UtcNow.AddMinutes(-5), playedSeconds: 90),
-            TestEntities.ListeningHistory(owner.Id, skipped.Id, DateTime.UtcNow, playedSeconds: 2, isCounted: false));
+            Assert.Empty(result);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningHistoryQuery(owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UncountedListens_AreIgnored()
+        {
+            var owner = TestEntities.User();
+            var counted = TestEntities.Track(owner, "Counted");
+            var skipped = TestEntities.Track(owner, "Skipped");
+            await SeedAsync(
+                owner, counted, skipped,
+                TestEntities.ListeningHistory(owner.Id, counted.Id, DateTime.UtcNow.AddMinutes(-5), playedSeconds: 90),
+                TestEntities.ListeningHistory(owner.Id, skipped.Id, DateTime.UtcNow, playedSeconds: 2, isCounted: false));
 
-        Assert.Equal(["Counted"], result.Select(track => track.Title));
+            var result = await CreateHandler().Handle(new GetListeningHistoryQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(["Counted"], result.Select(track => track.Title));
+        }
     }
 }

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

@@ -4,49 +4,50 @@ using Musify.Application.Tracks;
 using Musify.Application.Tracks.Responses;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class GetTrackByIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private GetTrackByIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_LocalTrack_ReturnsItWithOwnerAsArtist()
+    public sealed class GetTrackByIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User(1, "artist-name");
-        var track = TestEntities.Track(owner, "My Song");
-        await SeedAsync(owner, track);
+        private GetTrackByIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetTrackByIdQuery(track.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_LocalTrack_ReturnsItWithOwnerAsArtist()
+        {
+            var owner = TestEntities.User(1, "artist-name");
+            var track = TestEntities.Track(owner, "My Song");
+            await SeedAsync(owner, track);
 
-        Assert.False(result.IsError);
-        Assert.Equal("My Song", result.Value.Title);
-        Assert.Equal(owner.Name, result.Value.Artist);
-        var localResponse = Assert.IsType<TrackApplicationResponse>(result.Value);
-        Assert.Equal(owner.Id, localResponse.OwnerUserId);
-    }
+            var result = await CreateHandler().Handle(new GetTrackByIdQuery(track.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetTrackByIdQuery(Guid.NewGuid()), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal("My Song", result.Value.Title);
+            Assert.Equal(owner.Name, result.Value.Artist);
+            var localResponse = Assert.IsType<TrackApplicationResponse>(result.Value);
+            Assert.Equal(owner.Id, localResponse.OwnerUserId);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_TrackMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetTrackByIdQuery(Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ListensCount_OnlyCountsCountedListens()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(
-            owner, track,
-            TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 100),
-            TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 100),
-            TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 1, isCounted: false));
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new GetTrackByIdQuery(track.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ListensCount_OnlyCountsCountedListens()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(
+                owner, track,
+                TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 100),
+                TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 100),
+                TestEntities.ListeningHistory(owner.Id, track.Id, playedSeconds: 1, isCounted: false));
 
-        Assert.Equal(2, result.Value.ListensCount);
+            var result = await CreateHandler().Handle(new GetTrackByIdQuery(track.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(2, result.Value.ListensCount);
+        }
     }
 }

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

@@ -2,26 +2,27 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Tracks;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class GetTracksByUserIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private GetTracksByUserIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ReturnsOnlyTracksLinkedToThatUser()
+    public sealed class GetTracksByUserIdQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User(1, "owner");
-        var other = TestEntities.User(2, "other");
-        var mine = TestEntities.Track(owner, "Mine");
-        var theirs = TestEntities.Track(other, "Theirs");
-        await SeedAsync(
-            owner, other, mine, theirs);
+        private GetTracksByUserIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ReturnsOnlyTracksLinkedToThatUser()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var other = TestEntities.User(2, "other");
+            var mine = TestEntities.Track(owner, "Mine");
+            var theirs = TestEntities.Track(other, "Theirs");
+            await SeedAsync(
+                owner, other, mine, theirs);
 
-        Assert.False(result.IsError);
-        var track = Assert.Single(result.Value.Items);
-        Assert.Equal("Mine", track.Title);
+            var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var track = Assert.Single(result.Value.Items);
+            Assert.Equal("Mine", track.Title);
+        }
     }
 }

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

@@ -3,51 +3,52 @@ using Musify.Application.Tracks;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class GetTracksQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private GetTracksQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_NoNameFilter_ReturnsEveryTrackAUserOwns()
+    public sealed class GetTracksQueryHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var trackA = TestEntities.Track(owner, "Alpha");
-        var trackB = TestEntities.Track(owner, "Beta");
-        await SeedAsync(
-            owner, trackA, trackB);
+        private GetTracksQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetTracksQuery(Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-        Assert.Equal(2, result.TotalItemCount);
-        Assert.Equal(2, result.Items.Count);
-    }
+        [Fact]
+        public async Task Handle_NoNameFilter_ReturnsEveryTrackAUserOwns()
+        {
+            var owner = TestEntities.User();
+            var trackA = TestEntities.Track(owner, "Alpha");
+            var trackB = TestEntities.Track(owner, "Beta");
+            await SeedAsync(
+                owner, trackA, trackB);
 
-    [Fact]
-    public async Task Handle_NameFilter_ReturnsOnlyMatchingTracks()
-    {
-        var owner = TestEntities.User();
-        var match = TestEntities.Track(owner, "Bohemian Rhapsody");
-        var other = TestEntities.Track(owner, "Imagine");
-        await SeedAsync(
-            owner, match, other);
+            var result = await CreateHandler().Handle(new GetTracksQuery(Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            Assert.Equal(2, result.TotalItemCount);
+            Assert.Equal(2, result.Items.Count);
+        }
 
-        var result = await CreateHandler().Handle(new GetTracksQuery(Name: "rhapsody", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
-        var item = Assert.Single(result.Items);
-        Assert.Equal("Bohemian Rhapsody", item.Title);
-    }
+        [Fact]
+        public async Task Handle_NameFilter_ReturnsOnlyMatchingTracks()
+        {
+            var owner = TestEntities.User();
+            var match = TestEntities.Track(owner, "Bohemian Rhapsody");
+            var other = TestEntities.Track(owner, "Imagine");
+            await SeedAsync(
+                owner, match, other);
 
-    [Fact]
-    public async Task Handle_GenreFilter_ReturnsOnlyTracksWithThatTag()
-    {
-        var owner = TestEntities.User();
-        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);
+            var result = await CreateHandler().Handle(new GetTracksQuery(Name: "rhapsody", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+            var item = Assert.Single(result.Items);
+            Assert.Equal("Bohemian Rhapsody", item.Title);
+        }
 
-        var result = await CreateHandler().Handle(new GetTracksQuery(null, 1, 10, Genre.Indie), TestContext.Current.CancellationToken);
-        var item = Assert.Single(result.Items);
-        Assert.Equal("Loud", item.Title);
+        [Fact]
+        public async Task Handle_GenreFilter_ReturnsOnlyTracksWithThatTag()
+        {
+            var owner = TestEntities.User();
+            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);
+
+            var result = await CreateHandler().Handle(new GetTracksQuery(null, 1, 10, Genre.Indie), TestContext.Current.CancellationToken);
+            var item = Assert.Single(result.Items);
+            Assert.Equal("Loud", item.Title);
+        }
     }
 }

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

@@ -5,109 +5,110 @@ using Musify.Application.Tracks;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class RecordListeningProgressCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private RecordListeningProgressCommandHandler CreateHandler() => new(Database);
-
-    private async Task<ListeningHistory> ReloadAsync(Guid id) =>
-        await Database.ListeningHistories.AsNoTracking()
-            .SingleAsync(l => l.Id == id, TestContext.Current.CancellationToken);
-
-    private async Task<(User User, ListeningHistory Listen)> SeedListenAsync(
-        double durationSeconds, DateTime listenedAt)
+    public sealed class RecordListeningProgressCommandHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User();
-        var track = TestEntities.Track(user, durationSeconds: durationSeconds);
-        var listen = TestEntities.ListeningHistory(user.Id, track.Id, listenedAt, isCounted: false);
-        await SeedAsync(user, track, listen);
-        return (user, listen);
+        private RecordListeningProgressCommandHandler CreateHandler() => new(Database);
+
+        private async Task<ListeningHistory> ReloadAsync(Guid id) =>
+            await Database.ListeningHistories.AsNoTracking()
+                .SingleAsync(l => l.Id == id, TestContext.Current.CancellationToken);
+
+        private async Task<(User User, ListeningHistory Listen)> SeedListenAsync(
+            double durationSeconds, DateTime listenedAt)
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user, durationSeconds: durationSeconds);
+            var listen = TestEntities.ListeningHistory(user.Id, track.Id, listenedAt, isCounted: false);
+            await SeedAsync(user, track, listen);
+            return (user, listen);
+        }
+
+        [Fact]
+        public async Task Handle_BelowThreshold_StoresSecondsWithoutCounting()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+
+            var result = await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 10), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var stored = await ReloadAsync(listen.Id);
+            Assert.Equal(10, stored.PlayedSeconds);
+            Assert.False(stored.IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_ReachesThirtySeconds_MarksAsCounted()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 30), TestContext.Current.CancellationToken);
+
+            Assert.True((await ReloadAsync(listen.Id)).IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_ShortTrack_CountsAtHalfDuration()
+        {
+            var (user, listen) = await SeedListenAsync(20, DateTime.UtcNow.AddSeconds(-60));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 10), TestContext.Current.CancellationToken);
+
+            Assert.True((await ReloadAsync(listen.Id)).IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_LowerValueThanStored_KeepsHighest()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+            var handler = CreateHandler();
+
+            await handler.Handle(new RecordListeningProgressCommand(user.Id, listen.Id, 40), TestContext.Current.CancellationToken);
+            await handler.Handle(new RecordListeningProgressCommand(user.Id, listen.Id, 15), TestContext.Current.CancellationToken);
+
+            var stored = await ReloadAsync(listen.Id);
+            Assert.Equal(40, stored.PlayedSeconds);
+            Assert.True(stored.IsCounted);
+        }
+
+        [Fact]
+        public async Task Handle_MoreThanElapsedClock_IsCappedToElapsedTime()
+        {
+            var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-20));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 150), TestContext.Current.CancellationToken);
+
+            var stored = await ReloadAsync(listen.Id);
+            Assert.InRange(stored.PlayedSeconds!.Value, 24, 27);
+        }
+
+        [Fact]
+        public async Task Handle_MoreThanTrackDuration_IsCappedToDuration()
+        {
+            var (user, listen) = await SeedListenAsync(50, DateTime.UtcNow.AddMinutes(-30));
+
+            await CreateHandler().Handle(
+                new RecordListeningProgressCommand(user.Id, listen.Id, 900), TestContext.Current.CancellationToken);
+
+            Assert.Equal(52, (await ReloadAsync(listen.Id)).PlayedSeconds);
+        }
+
+        [Fact]
+        public async Task Handle_OtherUsersListen_ReturnsNotFound()
+        {
+            var (_, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
+
+            var result = await CreateHandler().Handle(
+                new RecordListeningProgressCommand(long.MaxValue, listen.Id, 10), TestContext.Current.CancellationToken);
+
+            Assert.True(result.IsError);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
     }
-
-    [Fact]
-    public async Task Handle_BelowThreshold_StoresSecondsWithoutCounting()
-    {
-        var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
-
-        var result = await CreateHandler().Handle(
-            new RecordListeningProgressCommand(user.Id, listen.Id, 10), TestContext.Current.CancellationToken);
-
-        Assert.False(result.IsError);
-        var stored = await ReloadAsync(listen.Id);
-        Assert.Equal(10, stored.PlayedSeconds);
-        Assert.False(stored.IsCounted);
-    }
-
-    [Fact]
-    public async Task Handle_ReachesThirtySeconds_MarksAsCounted()
-    {
-        var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
-
-        await CreateHandler().Handle(
-            new RecordListeningProgressCommand(user.Id, listen.Id, 30), TestContext.Current.CancellationToken);
-
-        Assert.True((await ReloadAsync(listen.Id)).IsCounted);
-    }
-
-    [Fact]
-    public async Task Handle_ShortTrack_CountsAtHalfDuration()
-    {
-        var (user, listen) = await SeedListenAsync(20, DateTime.UtcNow.AddSeconds(-60));
-
-        await CreateHandler().Handle(
-            new RecordListeningProgressCommand(user.Id, listen.Id, 10), TestContext.Current.CancellationToken);
-
-        Assert.True((await ReloadAsync(listen.Id)).IsCounted);
-    }
-
-    [Fact]
-    public async Task Handle_LowerValueThanStored_KeepsHighest()
-    {
-        var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
-        var handler = CreateHandler();
-
-        await handler.Handle(new RecordListeningProgressCommand(user.Id, listen.Id, 40), TestContext.Current.CancellationToken);
-        await handler.Handle(new RecordListeningProgressCommand(user.Id, listen.Id, 15), TestContext.Current.CancellationToken);
-
-        var stored = await ReloadAsync(listen.Id);
-        Assert.Equal(40, stored.PlayedSeconds);
-        Assert.True(stored.IsCounted);
-    }
-
-    [Fact]
-    public async Task Handle_MoreThanElapsedClock_IsCappedToElapsedTime()
-    {
-        var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-20));
-
-        await CreateHandler().Handle(
-            new RecordListeningProgressCommand(user.Id, listen.Id, 150), TestContext.Current.CancellationToken);
-
-        var stored = await ReloadAsync(listen.Id);
-        Assert.InRange(stored.PlayedSeconds!.Value, 24, 27);
-    }
-
-    [Fact]
-    public async Task Handle_MoreThanTrackDuration_IsCappedToDuration()
-    {
-        var (user, listen) = await SeedListenAsync(50, DateTime.UtcNow.AddMinutes(-30));
-
-        await CreateHandler().Handle(
-            new RecordListeningProgressCommand(user.Id, listen.Id, 900), TestContext.Current.CancellationToken);
-
-        Assert.Equal(52, (await ReloadAsync(listen.Id)).PlayedSeconds);
-    }
-
-    [Fact]
-    public async Task Handle_OtherUsersListen_ReturnsNotFound()
-    {
-        var (_, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
-
-        var result = await CreateHandler().Handle(
-            new RecordListeningProgressCommand(long.MaxValue, listen.Id, 10), TestContext.Current.CancellationToken);
-
-        Assert.True(result.IsError);
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
-
 }

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

@@ -9,77 +9,78 @@ using Musify.Domain.ValueObjects;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class RequestTrackUploadUrlsCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private readonly IStorageService storageService = Substitute.For<IStorageService>();
-
-    private RequestTrackUploadUrlsCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
+    public sealed class RequestTrackUploadUrlsCommandHandlerTests : HandlerTestBase
     {
-        storageService
-            .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");
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
+        private RequestTrackUploadUrlsCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
+        {
+            storageService
+                .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");
 
-        return new RequestTrackUploadUrlsCommandHandler(
-            new UploadIntentIssuer(
-                Database,
-                storageService,
-                new UploadIntentValidator(Database, storageService, config),
+            var config = uploadIntentConfig ?? TestConfigurations.UploadIntent();
+
+            return new RequestTrackUploadUrlsCommandHandler(
+                new UploadIntentIssuer(
+                    Database,
+                    storageService,
+                    new UploadIntentValidator(Database, storageService, config),
+                    TestConfigurations.Storage(),
+                    config,
+                    NoOpLogger<UploadIntentIssuer>()),
                 TestConfigurations.Storage(),
-                config,
-                NoOpLogger<UploadIntentIssuer>()),
-            TestConfigurations.Storage(),
-            TestConfigurations.Track(),
-            config);
-    }
+                TestConfigurations.Track(),
+                config);
+        }
 
-    [Fact]
-    public async Task Handle_UserExists_IssuesBothUploadUrlsAndCreatesIntents()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+        [Fact]
+        public async Task Handle_UserExists_IssuesBothUploadUrlsAndCreatesIntents()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        var command = new RequestTrackUploadUrlsCommand(user.Id, "webp", "image/webp", "mp3", "audio/mpeg");
+            var command = new RequestTrackUploadUrlsCommand(user.Id, "webp", "image/webp", "mp3", "audio/mpeg");
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        Assert.False(result.IsError);
-        Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.PictureUploadUrl);
-        Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.AudioUploadUrl);
+            Assert.False(result.IsError);
+            Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.PictureUploadUrl);
+            Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.AudioUploadUrl);
 
-        var intents = await Database.UploadIntents.Where(intent => intent.UserId == user.Id).ToListAsync(TestContext.Current.CancellationToken);
-        Assert.Equal(2, intents.Count);
-        Assert.Contains(intents, intent => intent.Purpose == UploadIntentPurpose.TrackPicture);
-        Assert.Contains(intents, intent => intent.Purpose == UploadIntentPurpose.TrackAudio);
-    }
+            var intents = await Database.UploadIntents.Where(intent => intent.UserId == user.Id).ToListAsync(TestContext.Current.CancellationToken);
+            Assert.Equal(2, intents.Count);
+            Assert.Contains(intents, intent => intent.Purpose == UploadIntentPurpose.TrackPicture);
+            Assert.Contains(intents, intent => intent.Purpose == UploadIntentPurpose.TrackAudio);
+        }
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var command = new RequestTrackUploadUrlsCommand(404, "webp", "image/webp", "mp3", "audio/mpeg");
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var command = new RequestTrackUploadUrlsCommand(404, "webp", "image/webp", "mp3", "audio/mpeg");
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-    [Fact]
-    public async Task Handle_UserAtActiveIntentLimit_ReturnsValidationErrorAndCreatesNothing()
-    {
-        var config = TestConfigurations.UploadIntent();
-        config.MaxActiveUploadIntentsPerUser = 1;
+        [Fact]
+        public async Task Handle_UserAtActiveIntentLimit_ReturnsValidationErrorAndCreatesNothing()
+        {
+            var config = TestConfigurations.UploadIntent();
+            config.MaxActiveUploadIntentsPerUser = 1;
 
-        var user = TestEntities.User();
-        await SeedAsync(user, TestEntities.UploadIntent(user.Id));
+            var user = TestEntities.User();
+            await SeedAsync(user, TestEntities.UploadIntent(user.Id));
 
-        var command = new RequestTrackUploadUrlsCommand(user.Id, "webp", "image/webp", "mp3", "audio/mpeg");
+            var command = new RequestTrackUploadUrlsCommand(user.Id, "webp", "image/webp", "mp3", "audio/mpeg");
 
-        var result = await CreateHandler(config).Handle(command, TestContext.Current.CancellationToken);
+            var result = await CreateHandler(config).Handle(command, TestContext.Current.CancellationToken);
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-        Assert.Equal(1, await Database.UploadIntents.CountAsync(TestContext.Current.CancellationToken));
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+            Assert.Equal(1, await Database.UploadIntents.CountAsync(TestContext.Current.CancellationToken));
+        }
     }
 }

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

@@ -8,94 +8,95 @@ using Musify.Application.Tracks;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.Tracks;
-
-public sealed class StartListeningCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Tracks
 {
-    private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
-
-    private StartListeningCommandHandler CreateHandler(PlaybackConfiguration? playback = null)
+    public sealed class StartListeningCommandHandlerTests : HandlerTestBase
     {
-        ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("ticket-token", 60));
+        private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
 
-        var issuer = new TrackStreamIssuer(
-            ticketService,
-            TestConfigurations.Track(),
-            TestConfigurations.StreamGateway("https://stream.musify.test"),
-            playback ?? TestConfigurations.Playback());
+        private StartListeningCommandHandler CreateHandler(PlaybackConfiguration? playback = null)
+        {
+            ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("ticket-token", 60));
 
-        return new StartListeningCommandHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<StartListeningCommandHandler>());
-    }
+            var issuer = new TrackStreamIssuer(
+                ticketService,
+                TestConfigurations.Track(),
+                TestConfigurations.StreamGateway("https://stream.musify.test"),
+                playback ?? TestConfigurations.Playback());
 
-    [Fact]
-    public async Task Handle_ProcessedTrack_IssuesTicketAndRecordsListen()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
+            return new StartListeningCommandHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<StartListeningCommandHandler>());
+        }
 
-        var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ProcessedTrack_IssuesTicketAndRecordsListen()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
 
-        Assert.False(result.IsError);
-        Assert.Equal("ticket-token", result.Value.Ticket);
-        Assert.Equal(60, result.Value.ExpiresInSeconds);
-        Assert.Contains("audio-folder", result.Value.ManifestUrl);
+            var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
 
-        var history = Assert.Single(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
-        Assert.Equal(owner.Id, history.UserId);
-        Assert.Equal(track.Id, history.TrackId);
-        Assert.Equal(history.Id, result.Value.ListenId);
-        Assert.False(history.IsCounted);
-        Assert.Null(history.PlayedSeconds);
-    }
+            Assert.False(result.IsError);
+            Assert.Equal("ticket-token", result.Value.Ticket);
+            Assert.Equal(60, result.Value.ExpiresInSeconds);
+            Assert.Contains("audio-folder", result.Value.ManifestUrl);
 
-    [Fact]
-    public async Task Handle_TrackMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new StartListeningCommand(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
+            var history = Assert.Single(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
+            Assert.Equal(owner.Id, history.UserId);
+            Assert.Equal(track.Id, history.TrackId);
+            Assert.Equal(history.Id, result.Value.ListenId);
+            Assert.False(history.IsCounted);
+            Assert.Null(history.PlayedSeconds);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_TrackMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new StartListeningCommand(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AudioNotProcessedYet_ReturnsConflict()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner, audio: TestEntities.PendingAudio());
-        await SeedAsync(owner, track);
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_AudioNotProcessedYet_ReturnsConflict()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner, audio: TestEntities.PendingAudio());
+            await SeedAsync(owner, track);
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AnonymousUser_AnonymousListeningDisabled_ReturnsUnauthorized()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
+            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        }
 
-        var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: false));
+        [Fact]
+        public async Task Handle_AnonymousUser_AnonymousListeningDisabled_ReturnsUnauthorized()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
 
-        var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
+            var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: false));
 
-        Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
-    }
+            var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AnonymousUser_AnonymousListeningEnabled_IssuesTicketWithoutRecordingHistory()
-    {
-        var owner = TestEntities.User();
-        var track = TestEntities.Track(owner);
-        await SeedAsync(owner, track);
+            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+        }
 
-        var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: true));
+        [Fact]
+        public async Task Handle_AnonymousUser_AnonymousListeningEnabled_IssuesTicketWithoutRecordingHistory()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
 
-        var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
+            var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: true));
 
-        Assert.False(result.IsError);
-        Assert.Equal("ticket-token", result.Value.Ticket);
-        Assert.Empty(await Database.ListeningHistories.ToListAsync(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);
+            Assert.Empty(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
+        }
     }
 }

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

@@ -6,66 +6,67 @@ using Musify.Domain.ValueObjects;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.UploadIntents;
-
-public sealed class UploadIntentJobsCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.UploadIntents
 {
-    [Fact]
-    public async Task ExpireUploadIntents_OverdueIssuedIntent_IsMarkedExpired()
+    public sealed class UploadIntentJobsCommandHandlerTests : HandlerTestBase
     {
-        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>());
+        [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);
+            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);
-    }
+            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>());
+        [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);
+            await handler.Handle(new ExpireUploadIntentsCommand(), TestContext.Current.CancellationToken);
 
-        Assert.Empty(await Database.UploadIntents.ToListAsync(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>());
+        [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);
+            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>());
-    }
+            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;
+        private static async IAsyncEnumerable<StorageObject> Objects(params StorageObject[] objects)
+        {
+            foreach (var item in objects)
+                yield return item;
 
-        await Task.CompletedTask;
+            await Task.CompletedTask;
+        }
     }
 }

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

@@ -4,57 +4,58 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Users;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class FollowUserCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private FollowUserCommandHandler CreateHandler() => new(Database, NoOpLogger<FollowUserCommandHandler>());
-
-    [Fact]
-    public async Task Handle_ValidTarget_CreatesFollow()
+    public sealed class FollowUserCommandHandlerTests : HandlerTestBase
     {
-        var follower = TestEntities.User(1, "follower");
-        var followed = TestEntities.User(2, "followed");
-        await SeedAsync(follower, followed);
+        private FollowUserCommandHandler CreateHandler() => new(Database, NoOpLogger<FollowUserCommandHandler>());
 
-        var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ValidTarget_CreatesFollow()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed);
 
-        Assert.False(result.IsError);
-        Assert.Single(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_AlreadyFollowing_IsIdempotent()
-    {
-        var follower = TestEntities.User(1, "follower");
-        var followed = TestEntities.User(2, "followed");
-        await SeedAsync(follower, followed, new Musify.Domain.Entities.UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
+            Assert.False(result.IsError);
+            Assert.Single(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_AlreadyFollowing_IsIdempotent()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed, new Musify.Domain.Entities.UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
 
-        Assert.False(result.IsError);
-        Assert.Single(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_SelfFollow_ReturnsValidationError()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+            Assert.False(result.IsError);
+            Assert.Single(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(new FollowUserCommand(user.Id, user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_SelfFollow_ReturnsValidationError()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        Assert.Equal(ErrorType.Validation, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new FollowUserCommand(user.Id, user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TargetMissing_ReturnsNotFound()
-    {
-        var follower = TestEntities.User();
-        await SeedAsync(follower);
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, 404), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TargetMissing_ReturnsNotFound()
+        {
+            var follower = TestEntities.User();
+            await SeedAsync(follower);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+            var result = await CreateHandler().Handle(new FollowUserCommand(follower.Id, 404), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -2,130 +2,131 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Users;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class GetListeningStatsQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private GetListeningStatsQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_NoHistory_ReturnsZeroes()
+    public sealed class GetListeningStatsQueryHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+        private GetListeningStatsQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NoHistory_ReturnsZeroes()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        Assert.Equal(0, result.TracksThisWeek);
-        Assert.Equal(0, result.SecondsThisWeek);
-        Assert.Equal(0, result.StreakDays);
-    }
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ListensThisWeek_CountsDistinctTracksAndTotalSeconds()
-    {
-        var user = TestEntities.User();
-        var trackA = TestEntities.Track(user, "Track A", durationSeconds: 200);
-        var trackB = TestEntities.Track(user, "Track B", durationSeconds: 100);
-        await SeedAsync(
-            user, trackA, trackB,
-            TestEntities.ListeningHistory(user.Id, trackA.Id, DateTime.UtcNow.AddDays(-1)),
-            TestEntities.ListeningHistory(user.Id, trackA.Id, DateTime.UtcNow.AddHours(-1)),
-            TestEntities.ListeningHistory(user.Id, trackB.Id, DateTime.UtcNow),
-            TestEntities.ListeningHistory(user.Id, trackB.Id, DateTime.UtcNow.AddDays(-10)));
+            Assert.Equal(0, result.TracksThisWeek);
+            Assert.Equal(0, result.SecondsThisWeek);
+            Assert.Equal(0, result.StreakDays);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ListensThisWeek_CountsDistinctTracksAndTotalSeconds()
+        {
+            var user = TestEntities.User();
+            var trackA = TestEntities.Track(user, "Track A", durationSeconds: 200);
+            var trackB = TestEntities.Track(user, "Track B", durationSeconds: 100);
+            await SeedAsync(
+                user, trackA, trackB,
+                TestEntities.ListeningHistory(user.Id, trackA.Id, DateTime.UtcNow.AddDays(-1)),
+                TestEntities.ListeningHistory(user.Id, trackA.Id, DateTime.UtcNow.AddHours(-1)),
+                TestEntities.ListeningHistory(user.Id, trackB.Id, DateTime.UtcNow),
+                TestEntities.ListeningHistory(user.Id, trackB.Id, DateTime.UtcNow.AddDays(-10)));
 
-        Assert.Equal(2, result.TracksThisWeek);
-        Assert.Equal(500, result.SecondsThisWeek);
-    }
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayedSeconds_SumsPlayedTimeInsteadOfDuration()
-    {
-        var user = TestEntities.User();
-        var track = TestEntities.Track(user, durationSeconds: 200);
-        await SeedAsync(
-            user, track,
-            TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 200),
-            TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 12, isCounted: false));
+            Assert.Equal(2, result.TracksThisWeek);
+            Assert.Equal(500, result.SecondsThisWeek);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_PlayedSeconds_SumsPlayedTimeInsteadOfDuration()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user, durationSeconds: 200);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 200),
+                TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 12, isCounted: false));
 
-        Assert.Equal(212, result.SecondsThisWeek);
-    }
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UncountedListens_AreExcludedFromTracksAndStreak()
-    {
-        var user = TestEntities.User();
-        var track = TestEntities.Track(user);
-        await SeedAsync(
-            user, track,
-            TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 3, isCounted: false));
+            Assert.Equal(212, result.SecondsThisWeek);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UncountedListens_AreExcludedFromTracksAndStreak()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, playedSeconds: 3, isCounted: false));
 
-        Assert.Equal(0, result.TracksThisWeek);
-        Assert.Equal(0, result.StreakDays);
-        Assert.Equal(3, result.SecondsThisWeek);
-    }
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ListenedTodayAndYesterday_StreakIsTwo()
-    {
-        var user = TestEntities.User();
-        var track = TestEntities.Track(user);
-        await SeedAsync(
-            user, track,
-            TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow),
-            TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-1)));
+            Assert.Equal(0, result.TracksThisWeek);
+            Assert.Equal(0, result.StreakDays);
+            Assert.Equal(3, result.SecondsThisWeek);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ListenedTodayAndYesterday_StreakIsTwo()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow),
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-1)));
 
-        Assert.Equal(2, result.StreakDays);
-    }
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_GapBeforeToday_StopsStreakAtGap()
-    {
-        var user = TestEntities.User();
-        var track = TestEntities.Track(user);
-        await SeedAsync(
-            user, track,
-            TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow),
-            TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-2)));
+            Assert.Equal(2, result.StreakDays);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_GapBeforeToday_StopsStreakAtGap()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow),
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-2)));
 
-        Assert.Equal(1, result.StreakDays);
-    }
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ListenedYesterdayButNotToday_StreakIsStillAlive()
-    {
-        var user = TestEntities.User();
-        var track = TestEntities.Track(user);
-        await SeedAsync(
-            user, track,
-            TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-1)));
+            Assert.Equal(1, result.StreakDays);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ListenedYesterdayButNotToday_StreakIsStillAlive()
+        {
+            var user = TestEntities.User();
+            var track = TestEntities.Track(user);
+            await SeedAsync(
+                user, track,
+                TestEntities.ListeningHistory(user.Id, track.Id, DateTime.UtcNow.AddDays(-1)));
 
-        Assert.Equal(1, result.StreakDays);
-    }
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [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)));
+            Assert.Equal(1, result.StreakDays);
+        }
 
-        var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+        [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)));
 
-        Assert.Equal(0, result.StreakDays);
+            var result = await CreateHandler().Handle(new GetListeningStatsQuery(user.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(0, result.StreakDays);
+        }
     }
 }

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

@@ -3,29 +3,30 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Users;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class GetUserByIdQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private GetUserByIdQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ExistingUser_ReturnsIt()
+    public sealed class GetUserByIdQueryHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User(1, "Jane Doe");
-        await SeedAsync(user);
+        private GetUserByIdQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetUserByIdQuery(1), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ExistingUser_ReturnsIt()
+        {
+            var user = TestEntities.User(1, "Jane Doe");
+            await SeedAsync(user);
 
-        Assert.False(result.IsError);
-        Assert.Equal("Jane Doe", result.Value.Name);
-    }
+            var result = await CreateHandler().Handle(new GetUserByIdQuery(1), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetUserByIdQuery(404), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal("Jane Doe", result.Value.Name);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetUserByIdQuery(404), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -6,89 +6,90 @@ using Musify.Application.Users.Responses;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class GetUserFollowersQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private GetUserFollowersQueryHandler CreateHandler() => new(Database);
-
-    private async Task<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Send(long? viewerId, long userId) =>
-        await CreateHandler().Handle(new GetUserFollowersQuery(viewerId, userId, 1, 20), TestContext.Current.CancellationToken);
-
-    [Fact]
-    public async Task Handle_OwnProfile_ReturnsFollowers()
+    public sealed class GetUserFollowersQueryHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User(1, "user");
-        var follower = TestEntities.User(2, "follower");
-        await SeedAsync(user, follower, new UserFollow { FollowerId = follower.Id, FollowedId = user.Id });
+        private GetUserFollowersQueryHandler CreateHandler() => new(Database);
 
-        var result = await Send(user.Id, user.Id);
+        private async Task<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Send(long? viewerId, long userId) =>
+            await CreateHandler().Handle(new GetUserFollowersQuery(viewerId, userId, 1, 20), TestContext.Current.CancellationToken);
 
-        Assert.False(result.IsError);
-        var item = Assert.Single(result.Value.Items);
-        Assert.Equal(follower.Id, item.Id);
-        Assert.False(item.IsFollowedByViewer);
-    }
+        [Fact]
+        public async Task Handle_OwnProfile_ReturnsFollowers()
+        {
+            var user = TestEntities.User(1, "user");
+            var follower = TestEntities.User(2, "follower");
+            await SeedAsync(user, follower, new UserFollow { FollowerId = follower.Id, FollowedId = user.Id });
 
-    [Fact]
-    public async Task Handle_MutualFollow_ReturnsFollowersWithViewerFollowState()
-    {
-        var viewer = TestEntities.User(1, "viewer");
-        var user = TestEntities.User(2, "user");
-        var other = TestEntities.User(3, "other");
-        await SeedAsync(
-            viewer, user, other,
-            new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id },
-            new UserFollow { FollowerId = user.Id, FollowedId = viewer.Id },
-            new UserFollow { FollowerId = other.Id, FollowedId = user.Id },
-            new UserFollow { FollowerId = viewer.Id, FollowedId = other.Id });
+            var result = await Send(user.Id, user.Id);
 
-        var result = await Send(viewer.Id, user.Id);
+            Assert.False(result.IsError);
+            var item = Assert.Single(result.Value.Items);
+            Assert.Equal(follower.Id, item.Id);
+            Assert.False(item.IsFollowedByViewer);
+        }
 
-        Assert.False(result.IsError);
-        Assert.Equal(2, result.Value.TotalItemCount);
-        Assert.All(result.Value.Items, item => Assert.Equal(item.Id == other.Id, item.IsFollowedByViewer));
-    }
+        [Fact]
+        public async Task Handle_MutualFollow_ReturnsFollowersWithViewerFollowState()
+        {
+            var viewer = TestEntities.User(1, "viewer");
+            var user = TestEntities.User(2, "user");
+            var other = TestEntities.User(3, "other");
+            await SeedAsync(
+                viewer, user, other,
+                new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id },
+                new UserFollow { FollowerId = user.Id, FollowedId = viewer.Id },
+                new UserFollow { FollowerId = other.Id, FollowedId = user.Id },
+                new UserFollow { FollowerId = viewer.Id, FollowedId = other.Id });
 
-    [Fact]
-    public async Task Handle_ViewerFollowsButNotFollowedBack_ReturnsForbidden()
-    {
-        var viewer = TestEntities.User(1, "viewer");
-        var user = TestEntities.User(2, "user");
-        await SeedAsync(viewer, user, new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id });
+            var result = await Send(viewer.Id, user.Id);
 
-        var result = await Send(viewer.Id, user.Id);
+            Assert.False(result.IsError);
+            Assert.Equal(2, result.Value.TotalItemCount);
+            Assert.All(result.Value.Items, item => Assert.Equal(item.Id == other.Id, item.IsFollowedByViewer));
+        }
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_ViewerFollowsButNotFollowedBack_ReturnsForbidden()
+        {
+            var viewer = TestEntities.User(1, "viewer");
+            var user = TestEntities.User(2, "user");
+            await SeedAsync(viewer, user, new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id });
 
-    [Fact]
-    public async Task Handle_FollowedByUserButNotFollowingBack_ReturnsForbidden()
-    {
-        var viewer = TestEntities.User(1, "viewer");
-        var user = TestEntities.User(2, "user");
-        await SeedAsync(viewer, user, new UserFollow { FollowerId = user.Id, FollowedId = viewer.Id });
+            var result = await Send(viewer.Id, user.Id);
 
-        var result = await Send(viewer.Id, user.Id);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_FollowedByUserButNotFollowingBack_ReturnsForbidden()
+        {
+            var viewer = TestEntities.User(1, "viewer");
+            var user = TestEntities.User(2, "user");
+            await SeedAsync(viewer, user, new UserFollow { FollowerId = user.Id, FollowedId = viewer.Id });
 
-    [Fact]
-    public async Task Handle_Anonymous_ReturnsForbidden()
-    {
-        await SeedAsync(TestEntities.User(1, "user"));
+            var result = await Send(viewer.Id, user.Id);
 
-        var result = await Send(null, 1);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
 
-        Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_Anonymous_ReturnsForbidden()
+        {
+            await SeedAsync(TestEntities.User(1, "user"));
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var result = await Send(1, 404);
+            var result = await Send(null, 1);
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var result = await Send(1, 404);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -4,71 +4,72 @@ using Musify.Application.Users;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class GetUserFollowingQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private GetUserFollowingQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_Anonymous_ReturnsFollowedUsers()
+    public sealed class GetUserFollowingQueryHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User(1, "user");
-        var followedA = TestEntities.User(2, "followedA");
-        var followedB = TestEntities.User(3, "followedB");
-        await SeedAsync(
-            user, followedA, followedB,
-            new UserFollow { FollowerId = user.Id, FollowedId = followedA.Id },
-            new UserFollow { FollowerId = user.Id, FollowedId = followedB.Id });
+        private GetUserFollowingQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetUserFollowingQuery(null, user.Id, 1, 20), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_Anonymous_ReturnsFollowedUsers()
+        {
+            var user = TestEntities.User(1, "user");
+            var followedA = TestEntities.User(2, "followedA");
+            var followedB = TestEntities.User(3, "followedB");
+            await SeedAsync(
+                user, followedA, followedB,
+                new UserFollow { FollowerId = user.Id, FollowedId = followedA.Id },
+                new UserFollow { FollowerId = user.Id, FollowedId = followedB.Id });
 
-        Assert.False(result.IsError);
-        Assert.Equal(2, result.Value.TotalItemCount);
-        Assert.All(result.Value.Items, item => Assert.False(item.IsFollowedByViewer));
-    }
+            var result = await CreateHandler().Handle(new GetUserFollowingQuery(null, user.Id, 1, 20), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_Viewer_MarksUsersTheViewerFollows()
-    {
-        var viewer = TestEntities.User(1, "viewer");
-        var user = TestEntities.User(2, "user");
-        var followedA = TestEntities.User(3, "followedA");
-        var followedB = TestEntities.User(4, "followedB");
-        await SeedAsync(
-            viewer, user, followedA, followedB,
-            new UserFollow { FollowerId = user.Id, FollowedId = followedA.Id },
-            new UserFollow { FollowerId = user.Id, FollowedId = followedB.Id },
-            new UserFollow { FollowerId = viewer.Id, FollowedId = followedA.Id });
+            Assert.False(result.IsError);
+            Assert.Equal(2, result.Value.TotalItemCount);
+            Assert.All(result.Value.Items, item => Assert.False(item.IsFollowedByViewer));
+        }
 
-        var result = await CreateHandler().Handle(new GetUserFollowingQuery(viewer.Id, user.Id, 1, 20), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_Viewer_MarksUsersTheViewerFollows()
+        {
+            var viewer = TestEntities.User(1, "viewer");
+            var user = TestEntities.User(2, "user");
+            var followedA = TestEntities.User(3, "followedA");
+            var followedB = TestEntities.User(4, "followedB");
+            await SeedAsync(
+                viewer, user, followedA, followedB,
+                new UserFollow { FollowerId = user.Id, FollowedId = followedA.Id },
+                new UserFollow { FollowerId = user.Id, FollowedId = followedB.Id },
+                new UserFollow { FollowerId = viewer.Id, FollowedId = followedA.Id });
 
-        Assert.False(result.IsError);
-        Assert.All(result.Value.Items, item => Assert.Equal(item.Id == followedA.Id, item.IsFollowedByViewer));
-    }
+            var result = await CreateHandler().Handle(new GetUserFollowingQuery(viewer.Id, user.Id, 1, 20), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_Pagination_ReturnsRequestedPage()
-    {
-        await SeedAsync(
-            TestEntities.User(1, "user"), TestEntities.User(2, "a"), TestEntities.User(3, "b"), TestEntities.User(4, "c"),
-            new UserFollow { FollowerId = 1, FollowedId = 2 },
-            new UserFollow { FollowerId = 1, FollowedId = 3 },
-            new UserFollow { FollowerId = 1, FollowedId = 4 });
+            Assert.False(result.IsError);
+            Assert.All(result.Value.Items, item => Assert.Equal(item.Id == followedA.Id, item.IsFollowedByViewer));
+        }
 
-        var result = await CreateHandler().Handle(new GetUserFollowingQuery(null, 1, 2, 2), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_Pagination_ReturnsRequestedPage()
+        {
+            await SeedAsync(
+                TestEntities.User(1, "user"), TestEntities.User(2, "a"), TestEntities.User(3, "b"), TestEntities.User(4, "c"),
+                new UserFollow { FollowerId = 1, FollowedId = 2 },
+                new UserFollow { FollowerId = 1, FollowedId = 3 },
+                new UserFollow { FollowerId = 1, FollowedId = 4 });
 
-        Assert.False(result.IsError);
-        Assert.Single(result.Value.Items);
-        Assert.Equal(3, result.Value.TotalItemCount);
-        Assert.False(result.Value.HasNextPage);
-    }
+            var result = await CreateHandler().Handle(new GetUserFollowingQuery(null, 1, 2, 2), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetUserFollowingQuery(null, 404, 1, 20), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Single(result.Value.Items);
+            Assert.Equal(3, result.Value.TotalItemCount);
+            Assert.False(result.Value.HasNextPage);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetUserFollowingQuery(null, 404, 1, 20), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -4,77 +4,78 @@ using Musify.Application.Users;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class GetUserProfileQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private GetUserProfileQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_ExistingUser_ReturnsFollowerAndFollowingCounts()
+    public sealed class GetUserProfileQueryHandlerTests : HandlerTestBase
     {
-        var user = TestEntities.User(1, "user");
-        var followerA = TestEntities.User(2, "followerA");
-        var followerB = TestEntities.User(3, "followerB");
-        var followed = TestEntities.User(4, "followed");
-        await SeedAsync(
-            user, followerA, followerB, followed,
-            new UserFollow { FollowerId = followerA.Id, FollowedId = user.Id },
-            new UserFollow { FollowerId = followerB.Id, FollowedId = user.Id },
-            new UserFollow { FollowerId = user.Id, FollowedId = followed.Id });
+        private GetUserProfileQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetUserProfileQuery(user.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ExistingUser_ReturnsFollowerAndFollowingCounts()
+        {
+            var user = TestEntities.User(1, "user");
+            var followerA = TestEntities.User(2, "followerA");
+            var followerB = TestEntities.User(3, "followerB");
+            var followed = TestEntities.User(4, "followed");
+            await SeedAsync(
+                user, followerA, followerB, followed,
+                new UserFollow { FollowerId = followerA.Id, FollowedId = user.Id },
+                new UserFollow { FollowerId = followerB.Id, FollowedId = user.Id },
+                new UserFollow { FollowerId = user.Id, FollowedId = followed.Id });
 
-        Assert.False(result.IsError);
-        Assert.Equal(2, result.Value.FollowersCount);
-        Assert.Equal(1, result.Value.FollowingCount);
-    }
+            var result = await CreateHandler().Handle(new GetUserProfileQuery(user.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_MutualFollow_ViewerCanSeeFollowersAndIsFollowing()
-    {
-        var viewer = TestEntities.User(1, "viewer");
-        var user = TestEntities.User(2, "user");
-        await SeedAsync(
-            viewer, user,
-            new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id },
-            new UserFollow { FollowerId = user.Id, FollowedId = viewer.Id });
+            Assert.False(result.IsError);
+            Assert.Equal(2, result.Value.FollowersCount);
+            Assert.Equal(1, result.Value.FollowingCount);
+        }
 
-        var result = await CreateHandler().Handle(new GetUserProfileQuery(user.Id, viewer.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_MutualFollow_ViewerCanSeeFollowersAndIsFollowing()
+        {
+            var viewer = TestEntities.User(1, "viewer");
+            var user = TestEntities.User(2, "user");
+            await SeedAsync(
+                viewer, user,
+                new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id },
+                new UserFollow { FollowerId = user.Id, FollowedId = viewer.Id });
 
-        Assert.True(result.Value.IsFollowing);
-        Assert.True(result.Value.CanViewFollowers);
-    }
+            var result = await CreateHandler().Handle(new GetUserProfileQuery(user.Id, viewer.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_OneWayFollow_ViewerCannotSeeFollowers()
-    {
-        var viewer = TestEntities.User(1, "viewer");
-        var user = TestEntities.User(2, "user");
-        await SeedAsync(viewer, user, new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id });
+            Assert.True(result.Value.IsFollowing);
+            Assert.True(result.Value.CanViewFollowers);
+        }
 
-        var result = await CreateHandler().Handle(new GetUserProfileQuery(user.Id, viewer.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_OneWayFollow_ViewerCannotSeeFollowers()
+        {
+            var viewer = TestEntities.User(1, "viewer");
+            var user = TestEntities.User(2, "user");
+            await SeedAsync(viewer, user, new UserFollow { FollowerId = viewer.Id, FollowedId = user.Id });
 
-        Assert.True(result.Value.IsFollowing);
-        Assert.False(result.Value.CanViewFollowers);
-    }
+            var result = await CreateHandler().Handle(new GetUserProfileQuery(user.Id, viewer.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_OwnProfile_CanSeeFollowersButIsNotFollowing()
-    {
-        await SeedAsync(TestEntities.User(1, "user"));
+            Assert.True(result.Value.IsFollowing);
+            Assert.False(result.Value.CanViewFollowers);
+        }
 
-        var result = await CreateHandler().Handle(new GetUserProfileQuery(1, 1), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_OwnProfile_CanSeeFollowersButIsNotFollowing()
+        {
+            await SeedAsync(TestEntities.User(1, "user"));
 
-        Assert.False(result.Value.IsFollowing);
-        Assert.True(result.Value.CanViewFollowers);
-    }
+            var result = await CreateHandler().Handle(new GetUserProfileQuery(1, 1), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UserMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new GetUserProfileQuery(404), TestContext.Current.CancellationToken);
+            Assert.False(result.Value.IsFollowing);
+            Assert.True(result.Value.CanViewFollowers);
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetUserProfileQuery(404), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -3,39 +3,40 @@ using Musify.Application.Users;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class GetUsersQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private GetUsersQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_NoSearch_ReturnsEveryUser()
+    public sealed class GetUsersQueryHandlerTests : HandlerTestBase
     {
-        await SeedAsync(TestEntities.User(1, "alice"), TestEntities.User(2, "bob"));
+        private GetUsersQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: null), TestContext.Current.CancellationToken);
-        Assert.Equal(2, result.TotalItemCount);
-    }
+        [Fact]
+        public async Task Handle_NoSearch_ReturnsEveryUser()
+        {
+            await SeedAsync(TestEntities.User(1, "alice"), TestEntities.User(2, "bob"));
 
-    [Fact]
-    public async Task Handle_UsernameSearch_ReturnsOnlyMatches()
-    {
-        await SeedAsync(TestEntities.User(1, "alice-wonderland"), TestEntities.User(2, "bob-builder"));
+            var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: null), TestContext.Current.CancellationToken);
+            Assert.Equal(2, result.TotalItemCount);
+        }
 
-        var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: "alice"), TestContext.Current.CancellationToken);
-        var user = Assert.Single(result.Items);
-        Assert.Equal(1, user.Id);
-    }
+        [Fact]
+        public async Task Handle_UsernameSearch_ReturnsOnlyMatches()
+        {
+            await SeedAsync(TestEntities.User(1, "alice-wonderland"), TestEntities.User(2, "bob-builder"));
 
-    [Fact]
-    public async Task Handle_Viewer_MarksFollowedUsers()
-    {
-        await SeedAsync(
-            TestEntities.User(1, "viewer"), TestEntities.User(2, "alice"), TestEntities.User(3, "bob"),
-            new UserFollow { FollowerId = 1, FollowedId = 2 });
+            var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: "alice"), TestContext.Current.CancellationToken);
+            var user = Assert.Single(result.Items);
+            Assert.Equal(1, user.Id);
+        }
 
-        var result = await CreateHandler().Handle(new GetUsersQuery(PageNumber: 1, PageSize: 10, UsernameSearch: null, ViewerId: 1), TestContext.Current.CancellationToken);
-        Assert.All(result.Items, item => Assert.Equal(item.Id == 2, item.IsFollowedByViewer));
+        [Fact]
+        public async Task Handle_Viewer_MarksFollowedUsers()
+        {
+            await SeedAsync(
+                TestEntities.User(1, "viewer"), TestEntities.User(2, "alice"), TestEntities.User(3, "bob"),
+                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.All(result.Items, item => Assert.Equal(item.Id == 2, item.IsFollowedByViewer));
+        }
     }
 }

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

@@ -3,33 +3,34 @@ using Musify.Application.Users;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class IsFollowingUserQueryHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private IsFollowingUserQueryHandler CreateHandler() => new(Database);
-
-    [Fact]
-    public async Task Handle_Following_ReturnsTrue()
+    public sealed class IsFollowingUserQueryHandlerTests : HandlerTestBase
     {
-        var follower = TestEntities.User(1, "follower");
-        var followed = TestEntities.User(2, "followed");
-        await SeedAsync(follower, followed, new UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
+        private IsFollowingUserQueryHandler CreateHandler() => new(Database);
 
-        var result = await CreateHandler().Handle(new IsFollowingUserQuery(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_Following_ReturnsTrue()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed, new UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
 
-        Assert.True(result);
-    }
+            var result = await CreateHandler().Handle(new IsFollowingUserQuery(follower.Id, followed.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NotFollowing_ReturnsFalse()
-    {
-        var follower = TestEntities.User(1, "follower");
-        var followed = TestEntities.User(2, "followed");
-        await SeedAsync(follower, followed);
+            Assert.True(result);
+        }
 
-        var result = await CreateHandler().Handle(new IsFollowingUserQuery(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NotFollowing_ReturnsFalse()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed);
 
-        Assert.False(result);
+            var result = await CreateHandler().Handle(new IsFollowingUserQuery(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result);
+        }
     }
 }

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

@@ -2,41 +2,42 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Application.Users;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class SyncUserCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private SyncUserCommandHandler CreateHandler() => new(Database, NoOpLogger<SyncUserCommandHandler>());
-
-    [Fact]
-    public async Task Handle_UnknownUser_ProvisionsIt()
+    public sealed class SyncUserCommandHandlerTests : HandlerTestBase
     {
-        var command = new SyncUserCommand(1, "Jane Doe", "Jane", "Doe", "https://avatar.example/jane.png");
+        private SyncUserCommandHandler CreateHandler() => new(Database, NoOpLogger<SyncUserCommandHandler>());
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_UnknownUser_ProvisionsIt()
+        {
+            var command = new SyncUserCommand(1, "Jane Doe", "Jane", "Doe", "https://avatar.example/jane.png");
 
-        Assert.False(result.IsError);
-        var stored = await Database.Users.FindAsync([1L], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal("Jane Doe", stored.Name);
-        Assert.Equal("https://avatar.example/jane.png", stored.ProfilePictureUrl);
-    }
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_ExistingUser_UpdatesProfileFields()
-    {
-        var user = TestEntities.User(1, "Old Name", profilePictureUrl: null);
-        await SeedAsync(user);
+            Assert.False(result.IsError);
+            var stored = await Database.Users.FindAsync([1L], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal("Jane Doe", stored.Name);
+            Assert.Equal("https://avatar.example/jane.png", stored.ProfilePictureUrl);
+        }
 
-        var command = new SyncUserCommand(1, "New Name", "New", "Name", "https://avatar.example/new.png");
+        [Fact]
+        public async Task Handle_ExistingUser_UpdatesProfileFields()
+        {
+            var user = TestEntities.User(1, "Old Name", profilePictureUrl: null);
+            await SeedAsync(user);
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+            var command = new SyncUserCommand(1, "New Name", "New", "Name", "https://avatar.example/new.png");
 
-        Assert.False(result.IsError);
-        var stored = await Database.Users.FindAsync([1L], TestContext.Current.CancellationToken);
-        Assert.NotNull(stored);
-        Assert.Equal("New Name", stored.Name);
-        Assert.Equal("NEW NAME", stored.NormalizedName);
-        Assert.Equal("https://avatar.example/new.png", stored.ProfilePictureUrl);
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var stored = await Database.Users.FindAsync([1L], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal("New Name", stored.Name);
+            Assert.Equal("NEW NAME", stored.NormalizedName);
+            Assert.Equal("https://avatar.example/new.png", stored.ProfilePictureUrl);
+        }
     }
 }

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

@@ -4,34 +4,35 @@ using Musify.Application.Users;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.Users;
-
-public sealed class UnfollowUserCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.Users
 {
-    private UnfollowUserCommandHandler CreateHandler() => new(Database, NoOpLogger<UnfollowUserCommandHandler>());
-
-    [Fact]
-    public async Task Handle_ExistingFollow_RemovesIt()
+    public sealed class UnfollowUserCommandHandlerTests : HandlerTestBase
     {
-        var follower = TestEntities.User(1, "follower");
-        var followed = TestEntities.User(2, "followed");
-        await SeedAsync(follower, followed, new UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
+        private UnfollowUserCommandHandler CreateHandler() => new(Database, NoOpLogger<UnfollowUserCommandHandler>());
 
-        var result = await CreateHandler().Handle(new UnfollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_ExistingFollow_RemovesIt()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed, new UserFollow { FollowerId = follower.Id, FollowedId = followed.Id });
 
-        Assert.False(result.IsError);
-        Assert.Empty(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
-    }
+            var result = await CreateHandler().Handle(new UnfollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NotFollowing_IsIdempotent()
-    {
-        var follower = TestEntities.User(1, "follower");
-        var followed = TestEntities.User(2, "followed");
-        await SeedAsync(follower, followed);
+            Assert.False(result.IsError);
+            Assert.Empty(await Database.UserFollows.ToListAsync(TestContext.Current.CancellationToken));
+        }
 
-        var result = await CreateHandler().Handle(new UnfollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NotFollowing_IsIdempotent()
+        {
+            var follower = TestEntities.User(1, "follower");
+            var followed = TestEntities.User(2, "followed");
+            await SeedAsync(follower, followed);
 
-        Assert.False(result.IsError);
+            var result = await CreateHandler().Handle(new UnfollowUserCommand(follower.Id, followed.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+        }
     }
 }