Make album cover pictures mandatory, unify cover handling with playlists

Albums previously had no cover concept at all: no picture upload
flow, no GET /albums/{id}/cover, and AlbumApplicationResponse's
image-key fields were plumbed but never populated. Description,
Pictures and TrackCount already lived on the shared Album base entity
for both local and external albums, so unifying the cover story only
required building the missing local-album picture pipeline.

Backend, cloning PlayList's existing async picture-processing
architecture exactly (MassTransit routing slip + saga), but making
the picture mandatory instead of optional (matching Track's pattern):

- AlbumPictures moves from all-nullable to required fields.
- New AlbumConfiguration (routes/sizes), deliberately without
  PlayList's preset-picture fallback since a picture is now required
  up front.
- CreateAlbum now takes a mandatory PictureIntentId, validates and
  consumes the upload intent, and kicks off the same
  copy-to-final -> resize -> upload -> update-entity routing slip
  PlayLists use, via a new AlbumProcessingState saga that marks the
  album Failed on a picture-processing failure.
- UpdateAlbum takes an optional NewPictureIntentId to replace the
  cover later.
- New GET /albums/{id}/cover and POST /albums/upload-picture
  endpoints, mirroring the playlist ones.
- New EF migration for the AlbumProcessingState saga table.

Frontend:

- AlbumForm gains a cover dropzone, required on create and optional
  on edit (via ImageDropzone's new `required` prop), uploaded through
  the same presigned-upload helper playlists use.
- New /api/albums/{id}/cover proxy route.
- PlaylistArt gains a generic coverUrl prop so AlbumHeader and the
  album list/detail cards render the real uploaded cover instead of
  only the track mosaic fallback.

Delete-time picture cleanup for albums is intentionally left as a
follow-up, matching the existing gap in playlist deletion.

backend/Tests/Musify.Api.Tests/Endpoints/AlbumEndpointsTests.cs

@@ -4,6 +4,8 @@ using Musify.Api.DataTransferObjects.Albums;
 using Musify.Api.DataTransferObjects.Users;
 using Musify.Api.Tests.TestSupport;
 using Musify.Application.Albums.Responses;
+using Musify.Application.Contracts;
+using NSubstitute;
 using Xunit;
 
 namespace Musify.Api.Tests.Endpoints
@@ -20,11 +22,30 @@ namespace Musify.Api.Tests.Endpoints
             return userId;
         }
 
+        private async Task<Guid> CreatePictureIntentAsync(HttpClient client)
+        {
+            fixture.StorageService
+                .GetUploadUrlAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TimeSpan>(), Arg.Any<CancellationToken>())
+                .Returns("https://storage.musify.test/presigned-upload");
+            fixture.StorageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 1024));
+
+            var response = await client.PostAsJsonAsync(
+                "/albums/upload-picture",
+                new RequestAlbumPictureUploadRequest("webp", "image/webp"),
+                TestContext.Current.CancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            var body = await response.Content.ReadFromJsonAsync<AlbumPictureUploadResponse>(TestContext.Current.CancellationToken);
+            return body!.IntentId;
+        }
+
         [Fact]
         public async Task PostAlbums_NoAuthHeader_ReturnsUnauthorized()
         {
             var response = await fixture.CreateAnonymousClient()
-                .PostAsJsonAsync("/albums", new CreateAlbumRequest("Unauthorized Album", null, null), TestContext.Current.CancellationToken);
+                .PostAsJsonAsync("/albums", new CreateAlbumRequest("Unauthorized Album", null, null, Guid.NewGuid()), TestContext.Current.CancellationToken);
 
             Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
         }
@@ -34,8 +55,9 @@ namespace Musify.Api.Tests.Endpoints
         {
             var userId = await CreateUserAsync();
             var client = fixture.CreateAuthenticatedClient(userId);
+            var pictureIntentId = await CreatePictureIntentAsync(client);
 
-            var response = await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("My Album", "desc", 2024), TestContext.Current.CancellationToken);
+            var response = await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("My Album", "desc", 2024, pictureIntentId), TestContext.Current.CancellationToken);
 
             Assert.Equal(HttpStatusCode.Created, response.StatusCode);
             var body = await response.Content.ReadFromJsonAsync<AlbumApplicationResponse>(TestContext.Current.CancellationToken);
@@ -50,7 +72,18 @@ namespace Musify.Api.Tests.Endpoints
             var userId = await CreateUserAsync();
             var client = fixture.CreateAuthenticatedClient(userId);
 
-            var response = await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("", null, null), TestContext.Current.CancellationToken);
+            var response = await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("", null, null, Guid.NewGuid()), TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task PostAlbums_MissingPictureIntent_ReturnsValidationProblem()
+        {
+            var userId = await CreateUserAsync();
+            var client = fixture.CreateAuthenticatedClient(userId);
+
+            var response = await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("No Picture", null, null, Guid.Empty), TestContext.Current.CancellationToken);
 
             Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
         }
@@ -60,7 +93,8 @@ namespace Musify.Api.Tests.Endpoints
         {
             var userId = await CreateUserAsync();
             var client = fixture.CreateAuthenticatedClient(userId);
-            var created = await (await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("Findable", null, null), TestContext.Current.CancellationToken))
+            var pictureIntentId = await CreatePictureIntentAsync(client);
+            var created = await (await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("Findable", null, null, pictureIntentId), TestContext.Current.CancellationToken))
                 .Content.ReadFromJsonAsync<AlbumApplicationResponse>(TestContext.Current.CancellationToken);
 
             var response = await fixture.CreateAnonymousClient().GetAsync($"/albums/{created!.Id}", TestContext.Current.CancellationToken);
@@ -73,7 +107,9 @@ namespace Musify.Api.Tests.Endpoints
         {
             var owner = await CreateUserAsync();
             var stranger = await CreateUserAsync();
-            var created = await (await fixture.CreateAuthenticatedClient(owner).PostAsJsonAsync("/albums", new CreateAlbumRequest("Owned", null, null), TestContext.Current.CancellationToken))
+            var ownerClient = fixture.CreateAuthenticatedClient(owner);
+            var pictureIntentId = await CreatePictureIntentAsync(ownerClient);
+            var created = await (await ownerClient.PostAsJsonAsync("/albums", new CreateAlbumRequest("Owned", null, null, pictureIntentId), TestContext.Current.CancellationToken))
                 .Content.ReadFromJsonAsync<AlbumApplicationResponse>(TestContext.Current.CancellationToken);
 
             var response = await fixture.CreateAuthenticatedClient(stranger).DeleteAsync($"/albums/{created!.Id}", TestContext.Current.CancellationToken);
@@ -86,7 +122,8 @@ namespace Musify.Api.Tests.Endpoints
         {
             var userId = await CreateUserAsync();
             var client = fixture.CreateAuthenticatedClient(userId);
-            var created = await (await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("Deletable", null, null), TestContext.Current.CancellationToken))
+            var pictureIntentId = await CreatePictureIntentAsync(client);
+            var created = await (await client.PostAsJsonAsync("/albums", new CreateAlbumRequest("Deletable", null, null, pictureIntentId), TestContext.Current.CancellationToken))
                 .Content.ReadFromJsonAsync<AlbumApplicationResponse>(TestContext.Current.CancellationToken);
 
             var deleteResponse = await client.DeleteAsync($"/albums/{created!.Id}", TestContext.Current.CancellationToken);

backend/Tests/Musify.Api.Tests/Validators/CreateAlbumRequestValidatorTests.cs

@@ -11,7 +11,7 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_ValidRequest_Passes()
         {
-            var result = validator.Validate(new CreateAlbumRequest("My Album", "A short description", 2024));
+            var result = validator.Validate(new CreateAlbumRequest("My Album", "A short description", 2024, Guid.NewGuid()));
 
             Assert.True(result.IsValid);
         }
@@ -19,7 +19,7 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_ValidRequestWithoutOptionalFields_Passes()
         {
-            var result = validator.Validate(new CreateAlbumRequest("My Album", null, null));
+            var result = validator.Validate(new CreateAlbumRequest("My Album", null, null, Guid.NewGuid()));
 
             Assert.True(result.IsValid);
         }
@@ -27,7 +27,7 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_BlankTitle_Fails()
         {
-            var result = validator.Validate(new CreateAlbumRequest("", null, null));
+            var result = validator.Validate(new CreateAlbumRequest("", null, null, Guid.NewGuid()));
 
             Assert.False(result.IsValid);
             Assert.Contains(result.Errors, e => e.PropertyName == nameof(CreateAlbumRequest.Title));
@@ -36,7 +36,7 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_TitleOverMaxLength_Fails()
         {
-            var result = validator.Validate(new CreateAlbumRequest(new string('a', 201), null, null));
+            var result = validator.Validate(new CreateAlbumRequest(new string('a', 201), null, null, Guid.NewGuid()));
 
             Assert.False(result.IsValid);
         }
@@ -44,7 +44,7 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_ReleaseYearBeforeTheEarliestBoundary_Fails()
         {
-            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Earliest - 1));
+            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Earliest - 1, Guid.NewGuid()));
 
             Assert.False(result.IsValid);
         }
@@ -52,7 +52,7 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_ReleaseYearAtTheEarliestBoundary_Passes()
         {
-            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Earliest));
+            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Earliest, Guid.NewGuid()));
 
             Assert.True(result.IsValid);
         }
@@ -60,7 +60,7 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_ReleaseYearAtTheLatestBoundary_Passes()
         {
-            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Latest));
+            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Latest, Guid.NewGuid()));
 
             Assert.True(result.IsValid);
         }
@@ -68,9 +68,18 @@ namespace Musify.Api.Tests.Validators
         [Fact]
         public void Validate_ReleaseYearPastTheLatestBoundary_Fails()
         {
-            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Latest + 1));
+            var result = validator.Validate(new CreateAlbumRequest("Title", null, AlbumReleaseYear.Latest + 1, Guid.NewGuid()));
 
             Assert.False(result.IsValid);
         }
+
+        [Fact]
+        public void Validate_EmptyPictureIntentId_Fails()
+        {
+            var result = validator.Validate(new CreateAlbumRequest("Title", null, null, Guid.Empty));
+
+            Assert.False(result.IsValid);
+            Assert.Contains(result.Errors, e => e.PropertyName == nameof(CreateAlbumRequest.PictureIntentId));
+        }
     }
 }

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

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

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

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

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

@@ -0,0 +1,75 @@
+using ErrorOr;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Albums;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts;
+using Musify.Application.Services;
+using Musify.Application.Tests.TestSupport;
+using NSubstitute;
+using Xunit;
+
+namespace Musify.Application.Tests.Albums
+{
+    public sealed class RequestAlbumPictureUploadCommandHandlerTests : HandlerTestBase
+    {
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
+
+        private RequestAlbumPictureUploadCommandHandler 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 RequestAlbumPictureUploadCommandHandler(
+                Database,
+                new UploadIntentValidator(Database, storageService),
+                storageService,
+                NoOpLogger<RequestAlbumPictureUploadCommandHandler>(),
+                TestConfigurations.Storage(),
+                TestConfigurations.Album(),
+                uploadIntentConfig ?? TestConfigurations.UploadIntent());
+        }
+
+        [Fact]
+        public async Task Handle_UserExists_IssuesUploadUrlAndCreatesIntent()
+        {
+            var user = TestEntities.User();
+            await SeedAsync(user);
+
+            var command = new RequestAlbumPictureUploadCommand(user.Id, "webp", "image/webp");
+
+            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));
+        }
+
+        [Fact]
+        public async Task Handle_UserMissing_ReturnsNotFound()
+        {
+            var command = new RequestAlbumPictureUploadCommand(404, "webp", "image/webp");
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_UserOverByteQuota_ReturnsValidationErrorAndCreatesNoIntent()
+        {
+            var config = TestConfigurations.UploadIntent();
+            config.MaxActiveUploadBytesPerUser = 100;
+
+            var user = TestEntities.User();
+            await SeedAsync(user);
+
+            var command = new RequestAlbumPictureUploadCommand(user.Id, "webp", "image/webp", ExpectedSizeBytes: 1_000_000);
+
+            var result = await CreateHandler(config).Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Validation, result.FirstError.Type);
+            Assert.Empty(await Database.UploadIntents.ToListAsync(TestContext.Current.CancellationToken));
+        }
+    }
+}

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

@@ -1,13 +1,26 @@
 using ErrorOr;
 using Musify.Application.Albums;
+using Musify.Application.Contracts;
+using Musify.Application.Services;
 using Musify.Application.Tests.TestSupport;
+using NSubstitute;
 using Xunit;
 
 namespace Musify.Application.Tests.Albums
 {
     public sealed class UpdateAlbumCommandHandlerTests : HandlerTestBase
     {
-        private UpdateAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<UpdateAlbumCommandHandler>());
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+        private readonly IStorageService storageService = Substitute.For<IStorageService>();
+
+        private UpdateAlbumCommandHandler CreateHandler() => new(
+            eventBus,
+            Database,
+            new UploadIntentValidator(Database, storageService),
+            NoOpLogger<UpdateAlbumCommandHandler>(),
+            TestConfigurations.Storage(),
+            TestConfigurations.Album(),
+            TestConfigurations.UploadIntent());
 
         [Fact]
         public async Task Handle_Owner_UpdatesTitleDescriptionAndReleaseYear()
@@ -16,7 +29,7 @@ namespace Musify.Application.Tests.Albums
             var album = TestEntities.UserAlbum(owner.Id, title: "Old Title", description: "Old", releaseYear: 2020);
             await SeedAsync(owner, album);
 
-            var command = new UpdateAlbumCommand(owner.Id, album.Id, "  New Title  ", "New description", 2025);
+            var command = new UpdateAlbumCommand(owner.Id, album.Id, "  New Title  ", "New description", 2025, null);
 
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
@@ -30,10 +43,33 @@ namespace Musify.Application.Tests.Albums
             Assert.Equal("NEW TITLE", stored.NormalizedTitle);
         }
 
+        [Fact]
+        public async Task Handle_ValidPictureIntent_UpdatesPictureAndPublishesSourceEvent()
+        {
+            storageService
+                .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+                .Returns(new ObjectMetaData("image/webp", 1024));
+
+            var owner = TestEntities.User();
+            var album = TestEntities.UserAlbum(owner.Id, title: "Old Title");
+            var intent = TestEntities.UploadIntent(owner.Id, Musify.Domain.ValueObjects.UploadIntentPurpose.AlbumPicture, objectName: "new-cover.webp");
+            await SeedAsync(owner, album, intent);
+
+            var command = new UpdateAlbumCommand(owner.Id, album.Id, "Old Title", null, null, intent.Id);
+
+            var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            var stored = await Database.UserAlbums.FindAsync([album.Id], TestContext.Current.CancellationToken);
+            Assert.NotNull(stored);
+            Assert.Equal("new-cover.webp", stored.Pictures.OriginalName);
+            await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.UpdateAlbumPictureSourceEvent>(), Arg.Any<CancellationToken>());
+        }
+
         [Fact]
         public async Task Handle_AlbumMissing_ReturnsNotFound()
         {
-            var command = new UpdateAlbumCommand(1, Guid.NewGuid(), "Title", null, null);
+            var command = new UpdateAlbumCommand(1, Guid.NewGuid(), "Title", null, null, null);
 
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 
@@ -48,7 +84,7 @@ namespace Musify.Application.Tests.Albums
             var album = TestEntities.UserAlbum(owner.Id);
             await SeedAsync(owner, stranger, album);
 
-            var command = new UpdateAlbumCommand(stranger.Id, album.Id, "Hijacked", null, null);
+            var command = new UpdateAlbumCommand(stranger.Id, album.Id, "Hijacked", null, null, null);
 
             var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
 

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

@@ -11,6 +11,8 @@ namespace Musify.Application.Tests.TestSupport
 
         public static PlayListConfiguration PlayList() => new();
 
+        public static AlbumConfiguration Album() => new();
+
         public static MixConfiguration Mix() => new();
 
         public static UploadIntentConfiguration UploadIntent() => new();