Use block-scoped namespaces in the test suite

Converts all 73 test source files from file-scoped (namespace X;) to
block-scoped (namespace X { ... }) declarations, re-indenting their
contents accordingly. Matches the existing convention already used in
several production files (e.g. Musify.Infrastructure.Configuration,
Musify.Application.Contracts).

Mechanical change only, done with a script, verified with a full
rebuild (0 warnings, 0 errors) and test run (257/257 passing).

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

@@ -5,88 +5,89 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private AddTrackToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToPlayListCommandHandler>());
-
-    [Fact]
-    public async Task Handle_FirstTrack_AddsItAtPositionZero()
+    public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
     {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        var track = TestEntities.LocalTrack(owner);
-        await SeedAsync(owner, playList, track);
+        private AddTrackToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToPlayListCommandHandler>());
 
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(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.LocalTrack(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 AddTrackToPlayListCommand(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.LocalTrack(owner, "Existing");
-        var newTrack = TestEntities.LocalTrack(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 AddTrackToPlayListCommand(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.LocalTrack(owner, "Existing");
+            var newTrack = TestEntities.LocalTrack(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 AddTrackToPlayListCommand(owner.Id, playList.Id, newTrack.Id), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(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 AddTrackToPlayListCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NotOwner_ReturnsUnauthorized()
-    {
-        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 AddTrackToPlayListCommand(stranger.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        {
+            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.Unauthorized, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(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.Unauthorized, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(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 AddTrackToPlayListCommand(owner.Id, playList.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackAlreadyInPlayList_ReturnsConflict()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        var track = TestEntities.LocalTrack(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 AddTrackToPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackAlreadyInPlayList_ReturnsConflict()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var track = TestEntities.LocalTrack(owner);
+            await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+            var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(owner.Id, playList.Id, track.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        }
     }
 }

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

@@ -8,97 +8,98 @@ using Musify.Domain.Entities;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists;
-
-public sealed class AddYouTubeTrackToPlayListCommandHandlerTests : HandlerTestBase
+namespace Musify.Application.Tests.PlayLists
 {
-    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-    private readonly IYouTubeMusicService youTubeMusicService = Substitute.For<IYouTubeMusicService>();
-
-    private AddYouTubeTrackToPlayListCommandHandler CreateHandler()
+    public sealed class AddYouTubeTrackToPlayListCommandHandlerTests : HandlerTestBase
     {
-        var provisioner = new YouTubeTrackProvisioner(
-            Database, youTubeMusicService, TestConfigurations.Track(), NoOpLogger<YouTubeTrackProvisioner>());
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+        private readonly IYouTubeMusicService youTubeMusicService = Substitute.For<IYouTubeMusicService>();
 
-        return new AddYouTubeTrackToPlayListCommandHandler(
-            Database,
-            eventBus,
-            youTubeMusicService,
-            provisioner,
-            TestConfigurations.Storage(),
-            TestConfigurations.Track(),
-            NoOpLogger<AddYouTubeTrackToPlayListCommandHandler>());
-    }
+        private AddYouTubeTrackToPlayListCommandHandler CreateHandler()
+        {
+            var provisioner = new YouTubeTrackProvisioner(
+                Database, youTubeMusicService, TestConfigurations.Track(), NoOpLogger<YouTubeTrackProvisioner>());
 
-    private static YouTubeSongResult BuildSong(string videoId) => new(
-        videoId, "Song Title", "Song Artist", "Song Album", 200, "https://img.example/thumb.jpg", false,
-        [new YouTubeArtistRef("artist-id", "Song Artist")]);
+            return new AddYouTubeTrackToPlayListCommandHandler(
+                Database,
+                eventBus,
+                youTubeMusicService,
+                provisioner,
+                TestConfigurations.Storage(),
+                TestConfigurations.Track(),
+                NoOpLogger<AddYouTubeTrackToPlayListCommandHandler>());
+        }
 
-    [Fact]
-    public async Task Handle_TrackAlreadyProcessedAndNotLinked_AddsItWithoutQueuingDownload()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        var track = TestEntities.ExternalTrack(externalId: "abc123");
-        await SeedAsync(owner, playList, track);
+        private static YouTubeSongResult BuildSong(string videoId) => new(
+            videoId, "Song Title", "Song Artist", "Song Album", 200, "https://img.example/thumb.jpg", false,
+            [new YouTubeArtistRef("artist-id", "Song Artist")]);
 
-        var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(owner.Id, playList.Id, "abc123"), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackAlreadyProcessedAndNotLinked_AddsItWithoutQueuingDownload()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var track = TestEntities.ExternalTrack(externalId: "abc123");
+            await SeedAsync(owner, playList, track);
 
-        Assert.False(result.IsError);
-        Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
-        await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.DownloadYouTubeTrackEvent>(), Arg.Any<CancellationToken>());
-    }
+            var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(owner.Id, playList.Id, "abc123"), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_UnknownVideo_ProvisionsTrackAndQueuesDownload()
-    {
-        youTubeMusicService.GetSongAsync("new-video", Arg.Any<CancellationToken>()).Returns(BuildSong("new-video"));
-        youTubeMusicService.ResolveArtworkUrl(Arg.Any<string>()).Returns(callInfo => callInfo.Arg<string>());
+            Assert.False(result.IsError);
+            Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
+            await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.DownloadYouTubeTrackEvent>(), Arg.Any<CancellationToken>());
+        }
 
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        await SeedAsync(owner, playList);
+        [Fact]
+        public async Task Handle_UnknownVideo_ProvisionsTrackAndQueuesDownload()
+        {
+            youTubeMusicService.GetSongAsync("new-video", Arg.Any<CancellationToken>()).Returns(BuildSong("new-video"));
+            youTubeMusicService.ResolveArtworkUrl(Arg.Any<string>()).Returns(callInfo => callInfo.Arg<string>());
 
-        var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(owner.Id, playList.Id, "new-video"), TestContext.Current.CancellationToken);
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            await SeedAsync(owner, playList);
 
-        Assert.False(result.IsError);
-        Assert.Equal("Song Title", result.Value.Title);
-        var track = await Database.ExternalTracks.SingleAsync(t => t.ExternalId == "new-video", TestContext.Current.CancellationToken);
-        Assert.True(track.Audio.DownloadRequested);
-        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.DownloadYouTubeTrackEvent>(), Arg.Any<CancellationToken>());
-    }
+            var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(owner.Id, playList.Id, "new-video"), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_PlayListMissing_ReturnsNotFound()
-    {
-        var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(1, Guid.NewGuid(), "abc123"), TestContext.Current.CancellationToken);
+            Assert.False(result.IsError);
+            Assert.Equal("Song Title", result.Value.Title);
+            var track = await Database.ExternalTracks.SingleAsync(t => t.ExternalId == "new-video", TestContext.Current.CancellationToken);
+            Assert.True(track.Audio.DownloadRequested);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.DownloadYouTubeTrackEvent>(), Arg.Any<CancellationToken>());
+        }
 
-        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
-    }
+        [Fact]
+        public async Task Handle_PlayListMissing_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(1, Guid.NewGuid(), "abc123"), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_NotOwner_ReturnsUnauthorized()
-    {
-        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 AddYouTubeTrackToPlayListCommand(stranger.Id, playList.Id, "abc123"), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        {
+            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.Unauthorized, result.FirstError.Type);
-    }
+            var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(stranger.Id, playList.Id, "abc123"), TestContext.Current.CancellationToken);
 
-    [Fact]
-    public async Task Handle_TrackAlreadyLinked_ReturnsConflict()
-    {
-        var owner = TestEntities.User();
-        var playList = TestEntities.PlayList(owner.Id);
-        var track = TestEntities.ExternalTrack(externalId: "abc123");
-        await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
+            Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(owner.Id, playList.Id, "abc123"), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TrackAlreadyLinked_ReturnsConflict()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var track = TestEntities.ExternalTrack(externalId: "abc123");
+            await SeedAsync(owner, playList, track, new PlayListHasTrack { PlayListId = playList.Id, TrackId = track.Id, Position = 0 });
 
-        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+            var result = await CreateHandler().Handle(new AddYouTubeTrackToPlayListCommand(owner.Id, playList.Id, "abc123"), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
+        }
     }
 }

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

@@ -6,80 +6,81 @@ 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),
-        NoOpLogger<CreatePlayListCommandHandler>(),
-        TestConfigurations.Storage(),
-        TestConfigurations.PlayList(),
-        TestConfigurations.UploadIntent());
-
-    [Fact]
-    public async Task Handle_NoPictureIntent_CreatesPlayListWithPresetPictures()
+    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),
+            NoOpLogger<CreatePlayListCommandHandler>(),
+            TestConfigurations.Storage(),
+            TestConfigurations.PlayList(),
+            TestConfigurations.UploadIntent());
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_NoPictureIntent_CreatesPlayListWithPresetPictures()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
 
-        Assert.False(result.IsError);
-        Assert.Equal("My Playlist", result.Value.Name);
-        Assert.Equal("PresetSmallPicture.webp", 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.Equal("PresetSmallPicture.webp", 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_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);
+            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>());
+        }
 
-        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_ReturnsUnauthorized()
-    {
-        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.Unauthorized, result.FirstError.Type);
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsUnauthorized()
+        {
+            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.Unauthorized, result.FirstError.Type);
+        }
     }
 }

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

@@ -4,32 +4,33 @@ 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);
-        var track = TestEntities.LocalTrack(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);
+            var track = TestEntities.LocalTrack(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);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

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

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

@@ -4,35 +4,36 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 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.LocalTrack(owner, "Second");
-        var first = TestEntities.LocalTrack(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), TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_TracksOrderedByPosition_ReturnsThemInOrder()
+        {
+            var owner = TestEntities.User();
+            var playList = TestEntities.PlayList(owner.Id);
+            var second = TestEntities.LocalTrack(owner, "Second");
+            var first = TestEntities.LocalTrack(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), 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);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -3,40 +3,41 @@ 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), TestContext.Current.CancellationToken);
+        [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"));
 
-        Assert.False(result.IsError);
-        var playList = Assert.Single(result.Value.Items);
-        Assert.Equal("Mine", playList.Name);
-    }
+            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-    [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"));
+            Assert.False(result.IsError);
+            var playList = Assert.Single(result.Value.Items);
+            Assert.Equal("Mine", playList.Name);
+        }
 
-        var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: "road", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+        [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"));
 
-        Assert.False(result.IsError);
-        var playList = Assert.Single(result.Value.Items);
-        Assert.Equal("Road Trip", playList.Name);
+            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: "road", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var playList = Assert.Single(result.Value.Items);
+            Assert.Equal("Road Trip", playList.Name);
+        }
     }
 }

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

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

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

@@ -4,56 +4,57 @@ 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.LocalTrack(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.LocalTrack(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_ReturnsUnauthorized()
-    {
-        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_ReturnsUnauthorized()
+        {
+            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.Unauthorized, 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.Unauthorized, 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);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
     }
 }

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

@@ -8,67 +8,68 @@ 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<CancellationToken>())
-            .Returns("https://storage.musify.test/presigned-upload");
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
 
-        return new RequestPlayListPictureUploadCommandHandler(
-            Database,
-            new UploadIntentValidator(Database, storageService),
-            storageService,
-            NoOpLogger<RequestPlayListPictureUploadCommandHandler>(),
-            TestConfigurations.Storage(),
-            TestConfigurations.PlayList(),
-            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<CancellationToken>())
+                .Returns("https://storage.musify.test/presigned-upload");
 
-    [Fact]
-    public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
-    {
-        var user = TestEntities.User();
-        await SeedAsync(user);
+            return new RequestPlayListPictureUploadCommandHandler(
+                Database,
+                new UploadIntentValidator(Database, storageService),
+                storageService,
+                NoOpLogger<RequestPlayListPictureUploadCommandHandler>(),
+                TestConfigurations.Storage(),
+                TestConfigurations.PlayList(),
+                uploadIntentConfig ?? TestConfigurations.UploadIntent());
+        }
 
-        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,75 +6,76 @@ 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),
-        NoOpLogger<UpdatePlayListCommandHandler>(),
-        TestConfigurations.Storage(),
-        TestConfigurations.PlayList(),
-        TestConfigurations.UploadIntent());
-
-    [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),
+            NoOpLogger<UpdatePlayListCommandHandler>(),
+            TestConfigurations.Storage(),
+            TestConfigurations.PlayList(),
+            TestConfigurations.UploadIntent());
 
-        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_ReturnsUnauthorized()
-    {
-        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_ReturnsUnauthorized()
+        {
+            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.Unauthorized, result.FirstError.Type);
-    }
+            var command = new UpdatePlayListCommand(stranger.Id, playList.Id, "Hijacked", null, null);
 
-    [Fact]
-    public async Task Handle_BlankNameAndDescription_LeavesThemUnchanged()
-    {
-        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.Equal(ErrorType.Unauthorized, result.FirstError.Type);
+        }
 
-        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+        [Fact]
+        public async Task Handle_BlankNameAndDescription_LeavesThemUnchanged()
+        {
+            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.Equal("Original description", result.Value.Description);
+            var command = new UpdatePlayListCommand(owner.Id, playList.Id, "   ", "   ", null);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal("Original Name", result.Value.Name);
+            Assert.Equal("Original description", result.Value.Description);
+        }
     }
 }