Add editorconfig and analyzers, format backend code

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

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

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

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

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

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

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

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

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

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

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

@@ -4,36 +4,35 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.Entities;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists
+namespace Musify.Application.Tests.PlayLists;
+
+public sealed class GetPlayListTracksQueryHandlerTests : HandlerTestBase
 {
-    public sealed class GetPlayListTracksQueryHandlerTests : HandlerTestBase
+    private GetPlayListTracksQueryHandler CreateHandler() => new(Database);
+
+    [Fact]
+    public async Task Handle_TracksOrderedByPosition_ReturnsThemInOrder()
     {
-        private GetPlayListTracksQueryHandler CreateHandler() => new(Database);
+        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 });
 
-        [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 });
+        var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-            var result = await CreateHandler().Handle(new GetPlayListTracksQuery(playList.Id, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+        Assert.False(result.IsError);
+        Assert.Equal(["First", "Second"], result.Value.Items.Select(track => track.Title));
+    }
 
-            Assert.False(result.IsError);
-            Assert.Equal(["First", "Second"], result.Value.Items.Select(track => track.Title));
-        }
+    [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_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);
-        }
+        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
     }
 }

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

@@ -3,57 +3,56 @@ using Musify.Application.Tests.TestSupport;
 using Musify.Domain.ValueObjects;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists
+namespace Musify.Application.Tests.PlayLists;
+
+public sealed class GetPlayListsByUserIdQueryHandlerTests : HandlerTestBase
 {
-    public sealed class GetPlayListsByUserIdQueryHandlerTests : HandlerTestBase
+    private GetPlayListsByUserIdQueryHandler CreateHandler() => new(Database);
+
+    [Fact]
+    public async Task Handle_ReturnsOnlyActivePlayListsForThatUser()
     {
-        private GetPlayListsByUserIdQueryHandler CreateHandler() => new(Database);
+        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_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"));
+        var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
+        Assert.False(result.IsError);
+        var playList = Assert.Single(result.Value.Items);
+        Assert.Equal("Mine", playList.Name);
+    }
 
-            Assert.False(result.IsError);
-            var playList = Assert.Single(result.Value.Items);
-            Assert.Equal("Mine", playList.Name);
-        }
+    [Fact]
+    public async Task Handle_OnlyPublic_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_OnlyPublic_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, OnlyPublic: true), TestContext.Current.CancellationToken);
 
-            var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10, OnlyPublic: true), TestContext.Current.CancellationToken);
+        Assert.False(result.IsError);
+        var playList = Assert.Single(result.Value.Items);
+        Assert.Equal("Public one", playList.Name);
+    }
 
-            Assert.False(result.IsError);
-            var playList = Assert.Single(result.Value.Items);
-            Assert.Equal("Public one", 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"));
 
-        [Fact]
-        public async Task Handle_NameFilter_ReturnsOnlyMatchingPlayLists()
-        {
-            var owner = TestEntities.User();
-            await SeedAsync(owner, TestEntities.PlayList(owner.Id, "Road Trip"), TestEntities.PlayList(owner.Id, "Study Focus"));
+        var result = await CreateHandler().Handle(new GetPlayListsByUserIdQuery(owner.Id, Name: "road", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-            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);
-        }
+        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,31 +2,30 @@ using Musify.Application.PlayLists;
 using Musify.Application.Tests.TestSupport;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists
+namespace Musify.Application.Tests.PlayLists;
+
+public sealed class GetPlayListsQueryHandlerTests : HandlerTestBase
 {
-    public sealed class GetPlayListsQueryHandlerTests : HandlerTestBase
+    private GetPlayListsQueryHandler CreateHandler() => new(Database);
+
+    [Fact]
+    public async Task Handle_ReturnsEveryPlayListPaged()
     {
-        private GetPlayListsQueryHandler CreateHandler() => new(Database);
+        var owner = TestEntities.User();
+        await SeedAsync(owner, TestEntities.PlayList(owner.Id, "One"), TestEntities.PlayList(owner.Id, "Two"));
 
-        [Fact]
-        public async Task Handle_ReturnsEveryPlayListPaged()
-        {
-            var owner = TestEntities.User();
-            await SeedAsync(owner, TestEntities.PlayList(owner.Id, "One"), TestEntities.PlayList(owner.Id, "Two"));
+        var result = await CreateHandler().Handle(new GetPlayListsQuery(PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-            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.Equal(2, result.Value.TotalItemCount);
-        }
+    [Fact]
+    public async Task Handle_NoPlayLists_ReturnsEmptyPage()
+    {
+        var result = await CreateHandler().Handle(new GetPlayListsQuery(PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
 
-        [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);
-        }
+        Assert.False(result.IsError);
+        Assert.Empty(result.Value.Items);
     }
 }

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

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

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

@@ -8,68 +8,67 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists
+namespace Musify.Application.Tests.PlayLists;
+
+public sealed class RequestPlayListPictureUploadCommandHandlerTests : HandlerTestBase
 {
-    public sealed class RequestPlayListPictureUploadCommandHandlerTests : HandlerTestBase
+    private readonly IStorageService storageService = Substitute.For<IStorageService>();
+
+    private RequestPlayListPictureUploadCommandHandler CreateHandler(UploadIntentConfiguration? uploadIntentConfig = null)
     {
-        private readonly IStorageService storageService = Substitute.For<IStorageService>();
+        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 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");
+        return new RequestPlayListPictureUploadCommandHandler(
+            Database,
+            new UploadIntentValidator(Database, storageService),
+            storageService,
+            NoOpLogger<RequestPlayListPictureUploadCommandHandler>(),
+            TestConfigurations.Storage(),
+            TestConfigurations.PlayList(),
+            uploadIntentConfig ?? TestConfigurations.UploadIntent());
+    }
 
-            return new RequestPlayListPictureUploadCommandHandler(
-                Database,
-                new UploadIntentValidator(Database, storageService),
-                storageService,
-                NoOpLogger<RequestPlayListPictureUploadCommandHandler>(),
-                TestConfigurations.Storage(),
-                TestConfigurations.PlayList(),
-                uploadIntentConfig ?? TestConfigurations.UploadIntent());
-        }
+    [Fact]
+    public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
+    {
+        var user = TestEntities.User();
+        await SeedAsync(user);
 
-        [Fact]
-        public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
-        {
-            var user = TestEntities.User();
-            await SeedAsync(user);
+        var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp");
 
-            var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp");
+        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.UploadUrl);
+        Assert.Single(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+    }
 
-            Assert.False(result.IsError);
-            Assert.Equal("https://storage.musify.test/presigned-upload", result.Value.UploadUrl);
-            Assert.Single(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
-        }
+    [Fact]
+    public async Task Handle_UserMissing_ReturnsNotFound()
+    {
+        var command = new RequestPlayListPictureUploadCommand(404, "webp", "image/webp");
 
-        [Fact]
-        public async Task Handle_UserMissing_ReturnsNotFound()
-        {
-            var command = new RequestPlayListPictureUploadCommand(404, "webp", "image/webp");
+        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_UserOverByteQuota_ReturnsValidationErrorAndCreatesNoIntent()
+    {
+        var config = TestConfigurations.UploadIntent();
+        config.MaxActiveUploadBytesPerUser = 100;
 
-        [Fact]
-        public async Task Handle_UserOverByteQuota_ReturnsValidationErrorAndCreatesNoIntent()
-        {
-            var config = TestConfigurations.UploadIntent();
-            config.MaxActiveUploadBytesPerUser = 100;
+        var user = TestEntities.User();
+        await SeedAsync(user);
 
-            var user = TestEntities.User();
-            await SeedAsync(user);
+        var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp", ExpectedSizeBytes: 1_000_000);
 
-            var command = new RequestPlayListPictureUploadCommand(user.Id, "webp", "image/webp", ExpectedSizeBytes: 1_000_000);
+        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.Empty(await Database.UploadIntents.ToListAsync(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,131 +6,130 @@ using Musify.Application.Tests.TestSupport;
 using NSubstitute;
 using Xunit;
 
-namespace Musify.Application.Tests.PlayLists
+namespace Musify.Application.Tests.PlayLists;
+
+public sealed class UpdatePlayListCommandHandlerTests : HandlerTestBase
 {
-    public sealed class UpdatePlayListCommandHandlerTests : HandlerTestBase
+    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()
     {
-        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
-        private readonly IStorageService storageService = Substitute.For<IStorageService>();
+        var owner = TestEntities.User();
+        var playList = TestEntities.PlayList(owner.Id, "Old Name");
+        await SeedAsync(owner, playList);
 
-        private UpdatePlayListCommandHandler CreateHandler() => new(
-            eventBus,
-            Database,
-            new UploadIntentValidator(Database, storageService),
-            NoOpLogger<UpdatePlayListCommandHandler>(),
-            TestConfigurations.Storage(),
-            TestConfigurations.PlayList(),
-            TestConfigurations.UploadIntent());
+        var command = new UpdatePlayListCommand(owner.Id, playList.Id, "New Name", null, null);
 
-        [Fact]
-        public async Task Handle_Owner_RenamesPlayList()
-        {
-            var owner = TestEntities.User();
-            var playList = TestEntities.PlayList(owner.Id, "Old Name");
-            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("New Name", result.Value.Name);
+    }
 
-            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+    [Fact]
+    public async Task Handle_PlayListMissing_ReturnsNotFound()
+    {
+        var command = new UpdatePlayListCommand(1, Guid.NewGuid(), "New Name", null, null);
 
-            Assert.False(result.IsError);
-            Assert.Equal("New Name", result.Value.Name);
-        }
+        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
-        [Fact]
-        public async Task Handle_PlayListMissing_ReturnsNotFound()
-        {
-            var command = new UpdatePlayListCommand(1, Guid.NewGuid(), "New Name", 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.NotFound, result.FirstError.Type);
-        }
+        var command = new UpdatePlayListCommand(stranger.Id, playList.Id, "Hijacked", 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.Unauthorized, 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.Equal(ErrorType.Unauthorized, result.FirstError.Type);
-        }
+        var command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, null, Musify.Domain.ValueObjects.PlaylistVisibility.Public);
 
-        [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.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_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_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(Musify.Domain.ValueObjects.PlaylistVisibility.Public, result.Value.Visibility);
-        }
+        var command = new UpdatePlayListCommand(owner.Id, playList.Id, "   ", "   ", 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.False(result.IsError);
+        Assert.Equal("Original Name", result.Value.Name);
+        Assert.Equal("Original description", result.Value.Description);
+    }
 
-            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+    [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));
 
-            Assert.False(result.IsError);
-            Assert.Equal("Original Name", result.Value.Name);
-            Assert.Equal("Original description", result.Value.Description);
-        }
+        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);
 
-        [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 command = new UpdatePlayListCommand(owner.Id, playList.Id, null, null, intent.Id);
 
-            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);
+        var result = await CreateHandler().Handle(command, TestContext.Current.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.Equal("new-cover.webp", 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>());
-        }
+        Assert.False(result.IsError);
+        Assert.Equal("new-cover.webp", 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>());
     }
 }