Add track status filter and counts, album track ids and bulk track deletion

GET /tracks/users/{userId} accepts repeated status values and returns the albums each track belongs to. GET /tracks/users/{userId}/status-counts, GET /albums/{id}/tracks/ids and DELETE /tracks with a list of track ids are new.
2026-09-25 01:14:59 +02:00
parent 9928840577
commit d839a72700
18 changed files with 773 additions and 8 deletions
@@ -0,0 +1,220 @@
+using System.Globalization;
+using System.Net;
+using System.Net.Http.Json;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Musify.Api.DataTransferObjects.Tracks;
+using Musify.Api.Tests.TestSupport;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.Persistence;
+using Xunit;
+
+namespace Musify.Api.Tests.Endpoints
+{
+    [Collection(ApiCollection.Name)]
+    public sealed class TrackLibraryEndpointsTests(ApiTestFixture fixture)
+    {
+        private async Task<Guid> SeedTrackAsync(
+            long ownerId,
+            string title,
+            ProcessingStatus status = ProcessingStatus.Completed)
+        {
+            using var scope = fixture.Services.CreateScope();
+            var database = scope.ServiceProvider.GetRequiredService<Database>();
+            var track = new Track
+            {
+                Title = title,
+                NormalizedTitle = title.ToUpperInvariant(),
+                OwnerUserId = ownerId,
+                Audio = new TrackAudio { TranscodeStatus = status, FolderName = status == ProcessingStatus.Completed ? "folder" : null }
+            };
+            database.Tracks.Add(track);
+            await database.SaveChangesAsync(TestContext.Current.CancellationToken);
+            return track.Id;
+        }
+
+        private async Task<Guid> SeedAlbumWithTracksAsync(long ownerId, params Guid[] trackIds)
+        {
+            using var scope = fixture.Services.CreateScope();
+            var database = scope.ServiceProvider.GetRequiredService<Database>();
+            var album = new Album { Title = "Album", NormalizedTitle = "ALBUM", OwnerUserId = ownerId };
+            database.Albums.Add(album);
+            var number = 1;
+            foreach (var trackId in trackIds)
+                database.AlbumHasTracks.Add(new AlbumHasTrack { AlbumId = album.Id, TrackId = trackId, TrackNumber = number++ });
+            await database.SaveChangesAsync(TestContext.Current.CancellationToken);
+            return album.Id;
+        }
+
+        private static int Number(JsonElement element) =>
+            element.ValueKind == JsonValueKind.String
+                ? int.Parse(element.GetString()!, CultureInfo.InvariantCulture)
+                : element.GetInt32();
+
+        private static async Task<JsonElement> ReadJsonAsync(HttpResponseMessage response)
+        {
+            var text = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken);
+            return JsonDocument.Parse(text).RootElement.Clone();
+        }
+
+        [Fact]
+        public async Task GetUserTracks_StatusFilterBindsRepeatedQueryValues()
+        {
+            var userId = await fixture.SeedUserAsync();
+            await SeedTrackAsync(userId, "Done");
+            await SeedTrackAsync(userId, "Pending", ProcessingStatus.Pending);
+            await SeedTrackAsync(userId, "Failed", ProcessingStatus.Failed);
+
+            var response = await fixture.CreateAnonymousClient().GetAsync(
+                $"/tracks/users/{userId.ToString(CultureInfo.InvariantCulture)}?status=Pending&status=Failed", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await ReadJsonAsync(response);
+            var titles = body.GetProperty("items").EnumerateArray().Select(i => i.GetProperty("title").GetString()).Order().ToList();
+            Assert.Equal(["Failed", "Pending"], titles);
+            Assert.Equal(2, Number(body.GetProperty("totalItemCount")));
+        }
+
+        [Fact]
+        public async Task GetUserTracks_ReturnsAlbumsOfEachTrack()
+        {
+            var userId = await fixture.SeedUserAsync();
+            var trackId = await SeedTrackAsync(userId, "In album");
+            var albumId = await SeedAlbumWithTracksAsync(userId, trackId);
+
+            var response = await fixture.CreateAnonymousClient().GetAsync(
+                $"/tracks/users/{userId.ToString(CultureInfo.InvariantCulture)}", TestContext.Current.CancellationToken);
+
+            var body = await ReadJsonAsync(response);
+            var albums = body.GetProperty("items")[0].GetProperty("albums");
+            Assert.Equal(1, albums.GetArrayLength());
+            Assert.Equal(albumId, albums[0].GetProperty("id").GetGuid());
+            Assert.Equal("Album", albums[0].GetProperty("title").GetString());
+        }
+
+        [Fact]
+        public async Task GetStatusCounts_Owner_ReturnsCountsPerStatus()
+        {
+            var userId = await fixture.SeedUserAsync();
+            await SeedTrackAsync(userId, "A");
+            await SeedTrackAsync(userId, "B", ProcessingStatus.Processing);
+            await SeedTrackAsync(userId, "C", ProcessingStatus.Failed);
+
+            var response = await fixture.CreateAuthenticatedClient(userId).GetAsync(
+                $"/tracks/users/{userId.ToString(CultureInfo.InvariantCulture)}/status-counts", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await ReadJsonAsync(response);
+            Assert.Equal(3, Number(body.GetProperty("total")));
+            Assert.Equal(1, Number(body.GetProperty("completed")));
+            Assert.Equal(1, Number(body.GetProperty("processing")));
+            Assert.Equal(1, Number(body.GetProperty("failed")));
+            Assert.Equal(0, Number(body.GetProperty("pending")));
+        }
+
+        [Fact]
+        public async Task GetStatusCounts_AnotherUser_ReturnsForbidden()
+        {
+            var owner = await fixture.SeedUserAsync();
+            var stranger = await fixture.SeedUserAsync();
+
+            var response = await fixture.CreateAuthenticatedClient(stranger).GetAsync(
+                $"/tracks/users/{owner.ToString(CultureInfo.InvariantCulture)}/status-counts", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetStatusCounts_Anonymous_ReturnsUnauthorized()
+        {
+            var response = await fixture.CreateAnonymousClient().GetAsync("/tracks/users/1/status-counts", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetAlbumTrackIds_Owner_ReturnsIdsInOrder()
+        {
+            var userId = await fixture.SeedUserAsync();
+            var first = await SeedTrackAsync(userId, "First");
+            var second = await SeedTrackAsync(userId, "Second");
+            var albumId = await SeedAlbumWithTracksAsync(userId, second, first);
+
+            var response = await fixture.CreateAuthenticatedClient(userId).GetAsync($"/albums/{albumId}/tracks/ids", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await ReadJsonAsync(response);
+            var ids = body.GetProperty("trackIds").EnumerateArray().Select(e => e.GetGuid()).ToList();
+            Assert.Equal([second, first], ids);
+        }
+
+        [Fact]
+        public async Task GetAlbumTrackIds_NotTheOwner_ReturnsForbidden()
+        {
+            var owner = await fixture.SeedUserAsync();
+            var stranger = await fixture.SeedUserAsync();
+            var albumId = await SeedAlbumWithTracksAsync(owner);
+
+            var response = await fixture.CreateAuthenticatedClient(stranger).GetAsync($"/albums/{albumId}/tracks/ids", TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task DeleteTracks_Anonymous_ReturnsUnauthorized()
+        {
+            var request = new HttpRequestMessage(HttpMethod.Delete, "/tracks") { Content = JsonContent.Create(new DeleteTracksRequest([Guid.NewGuid()])) };
+
+            var response = await fixture.CreateAnonymousClient().SendAsync(request, TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task DeleteTracks_EmptyList_ReturnsBadRequest()
+        {
+            var userId = await fixture.SeedUserAsync();
+            var request = new HttpRequestMessage(HttpMethod.Delete, "/tracks") { Content = JsonContent.Create(new DeleteTracksRequest([])) };
+
+            var response = await fixture.CreateAuthenticatedClient(userId).SendAsync(request, TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        }
+
+        [Fact]
+        public async Task DeleteTracks_OwnTracks_MarksThemRemovingAndReportsFailures()
+        {
+            var userId = await fixture.SeedUserAsync();
+            var done = await SeedTrackAsync(userId, "Done");
+            var busy = await SeedTrackAsync(userId, "Busy", ProcessingStatus.Pending);
+            var request = new HttpRequestMessage(HttpMethod.Delete, "/tracks") { Content = JsonContent.Create(new DeleteTracksRequest([done, busy])) };
+
+            var response = await fixture.CreateAuthenticatedClient(userId).SendAsync(request, TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var body = await ReadJsonAsync(response);
+            Assert.Equal([done], body.GetProperty("deletedTrackIds").EnumerateArray().Select(e => e.GetGuid()).ToList());
+            Assert.Equal([busy], body.GetProperty("failedTrackIds").EnumerateArray().Select(e => e.GetGuid()).ToList());
+
+            using var scope = fixture.Services.CreateScope();
+            var database = scope.ServiceProvider.GetRequiredService<Database>();
+            var stored = await database.Tracks.AsNoTracking().SingleAsync(t => t.Id == done, TestContext.Current.CancellationToken);
+            Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
+        }
+
+        [Fact]
+        public async Task DeleteTracks_TrackOfAnotherUser_ReturnsForbidden()
+        {
+            var owner = await fixture.SeedUserAsync();
+            var stranger = await fixture.SeedUserAsync();
+            var trackId = await SeedTrackAsync(owner, "Theirs");
+            var request = new HttpRequestMessage(HttpMethod.Delete, "/tracks") { Content = JsonContent.Create(new DeleteTracksRequest([trackId])) };
+
+            var response = await fixture.CreateAuthenticatedClient(stranger).SendAsync(request, TestContext.Current.CancellationToken);
+
+            Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
+        }
+    }
+}
@@ -0,0 +1,53 @@
+using ErrorOr;
+using Musify.Application.Albums;
+using Musify.Application.Tests.TestSupport;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Xunit;
+
+namespace Musify.Application.Tests.Albums
+{
+    public sealed class GetAlbumTrackIdsQueryHandlerTests : HandlerTestBase
+    {
+        private GetAlbumTrackIdsQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_Owner_ReturnsAllActiveTrackIdsInOrderBeyondAPage()
+        {
+            var owner = TestEntities.User();
+            var album = TestEntities.Album(owner.Id);
+            var tracks = Enumerable.Range(1, 120).Select(i => TestEntities.Track(owner, $"T{i}")).ToList();
+            var removing = TestEntities.Track(owner, "Removing", lifeCycleStatus: LifeCycleStatus.Removing);
+            await SeedAsync([owner, album, removing, .. tracks]);
+            var links = tracks.Select((t, i) => new AlbumHasTrack { AlbumId = album.Id, TrackId = t.Id, TrackNumber = i + 1 }).ToList();
+            links.Add(new AlbumHasTrack { AlbumId = album.Id, TrackId = removing.Id, TrackNumber = 999 });
+            await SeedAsync([.. links]);
+
+            var result = await CreateHandler().Handle(new GetAlbumTrackIdsQuery(owner.Id, album.Id), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(tracks.Select(t => t.Id), result.Value.TrackIds);
+        }
+
+        [Fact]
+        public async Task Handle_NotOwner_ReturnsForbidden()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var album = TestEntities.Album(owner.Id);
+            await SeedAsync(owner, stranger, album);
+
+            var result = await CreateHandler().Handle(new GetAlbumTrackIdsQuery(stranger.Id, album.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+        }
+
+        [Fact]
+        public async Task Handle_MissingAlbum_ReturnsNotFound()
+        {
+            var result = await CreateHandler().Handle(new GetAlbumTrackIdsQuery(1, Guid.NewGuid()), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
+        }
+    }
+}
@@ -0,0 +1,81 @@
+using ErrorOr;
+using Musify.Application.Contracts;
+using Musify.Application.Events;
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Tracks;
+using Musify.Domain.ValueObjects;
+using NSubstitute;
+using Xunit;
+
+namespace Musify.Application.Tests.Tracks
+{
+    public sealed class DeleteTracksCommandHandlerTests : HandlerTestBase
+    {
+        private readonly IEventBus eventBus = Substitute.For<IEventBus>();
+
+        private DeleteTracksCommandHandler CreateHandler() => new(Database, eventBus, NoOpLogger<DeleteTracksCommandHandler>());
+
+        [Fact]
+        public async Task Handle_OwnTracks_MarksAllAsRemovingAndPublishesOneEventEach()
+        {
+            var owner = TestEntities.User();
+            var first = TestEntities.Track(owner, "One");
+            var second = TestEntities.Track(owner, "Two");
+            await SeedAsync(owner, first, second);
+
+            var result = await CreateHandler().Handle(new DeleteTracksCommand(owner.Id, [first.Id, second.Id]), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(2, result.Value.DeletedTrackIds.Count);
+            Assert.Empty(result.Value.FailedTrackIds);
+            Assert.All(Database.Tracks.ToList(), track => Assert.Equal(LifeCycleStatus.Removing, track.LifeCycleStatus));
+            await eventBus.Received(2).PublishAsync(Arg.Any<DeleteTrackEvent>(), Arg.Any<CancellationToken>());
+        }
+
+        [Fact]
+        public async Task Handle_TrackOfAnotherUser_ReturnsForbiddenAndDeletesNothing()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var stranger = TestEntities.User(2, "stranger");
+            var mine = TestEntities.Track(owner, "Mine");
+            var theirs = TestEntities.Track(stranger, "Theirs");
+            await SeedAsync(owner, stranger, mine, theirs);
+
+            var result = await CreateHandler().Handle(new DeleteTracksCommand(owner.Id, [mine.Id, theirs.Id]), TestContext.Current.CancellationToken);
+
+            Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
+            Assert.All(Database.Tracks.ToList(), track => Assert.Equal(LifeCycleStatus.Active, track.LifeCycleStatus));
+            await eventBus.DidNotReceive().PublishAsync(Arg.Any<DeleteTrackEvent>(), Arg.Any<CancellationToken>());
+        }
+
+        [Fact]
+        public async Task Handle_ProcessingAndMissingTracks_AreReturnedAsFailed()
+        {
+            var owner = TestEntities.User();
+            var done = TestEntities.Track(owner, "Done");
+            var busy = TestEntities.Track(owner, "Busy", audio: TestEntities.PendingAudio());
+            var missing = Guid.NewGuid();
+            await SeedAsync(owner, done, busy);
+
+            var result = await CreateHandler().Handle(new DeleteTracksCommand(owner.Id, [done.Id, busy.Id, missing]), TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal([done.Id], result.Value.DeletedTrackIds);
+            Assert.Equal([busy.Id, missing], result.Value.FailedTrackIds);
+            Assert.Equal(LifeCycleStatus.Active, Database.Tracks.Single(t => t.Id == busy.Id).LifeCycleStatus);
+        }
+
+        [Fact]
+        public async Task Handle_DuplicateIds_AreDeletedOnce()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner);
+            await SeedAsync(owner, track);
+
+            var result = await CreateHandler().Handle(new DeleteTracksCommand(owner.Id, [track.Id, track.Id]), TestContext.Current.CancellationToken);
+
+            Assert.Single(result.Value.DeletedTrackIds);
+            await eventBus.Received(1).PublishAsync(Arg.Any<DeleteTrackEvent>(), Arg.Any<CancellationToken>());
+        }
+    }
+}
@@ -0,0 +1,45 @@
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Tracks;
+using Musify.Domain.ValueObjects;
+using Xunit;
+
+namespace Musify.Application.Tests.Tracks
+{
+    public sealed class GetTrackStatusCountsQueryHandlerTests : HandlerTestBase
+    {
+        [Fact]
+        public async Task Handle_CountsOnlyActiveTracksOfTheUser()
+        {
+            var owner = TestEntities.User(1, "owner");
+            var other = TestEntities.User(2, "other");
+            await SeedAsync(
+                owner, other,
+                TestEntities.Track(owner, "Done 1"),
+                TestEntities.Track(owner, "Done 2"),
+                TestEntities.Track(owner, "Pending", audio: TestEntities.PendingAudio()),
+                TestEntities.Track(owner, "Processing", audio: new TrackAudio { TranscodeStatus = ProcessingStatus.Processing }),
+                TestEntities.Track(owner, "Failed", audio: new TrackAudio { TranscodeStatus = ProcessingStatus.Failed }),
+                TestEntities.Track(owner, "Removing", lifeCycleStatus: LifeCycleStatus.Removing),
+                TestEntities.Track(other, "Theirs"));
+
+            var counts = await new GetTrackStatusCountsQueryHandler(Database)
+                .Handle(new GetTrackStatusCountsQuery(owner.Id), TestContext.Current.CancellationToken);
+
+            Assert.Equal(5, counts.Total);
+            Assert.Equal(1, counts.Pending);
+            Assert.Equal(1, counts.Processing);
+            Assert.Equal(2, counts.Completed);
+            Assert.Equal(1, counts.Failed);
+        }
+
+        [Fact]
+        public async Task Handle_NoTracks_ReturnsZeros()
+        {
+            var counts = await new GetTrackStatusCountsQueryHandler(Database)
+                .Handle(new GetTrackStatusCountsQuery(99), TestContext.Current.CancellationToken);
+
+            Assert.Equal(0, counts.Total);
+            Assert.Equal(0, counts.Completed);
+        }
+    }
+}
@@ -0,0 +1,79 @@
+using Musify.Application.Tests.TestSupport;
+using Musify.Application.Tracks;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Xunit;
+
+namespace Musify.Application.Tests.Tracks
+{
+    public sealed class GetTracksByUserIdStatusAndAlbumsTests : HandlerTestBase
+    {
+        private GetTracksByUserIdQueryHandler CreateHandler() => new(Database);
+
+        [Fact]
+        public async Task Handle_StatusFilter_ReturnsOnlyMatchingStatuses()
+        {
+            var owner = TestEntities.User();
+            var done = TestEntities.Track(owner, "Done");
+            var pending = TestEntities.Track(owner, "Pending", audio: TestEntities.PendingAudio());
+            var failed = TestEntities.Track(owner, "Failed", audio: new TrackAudio { TranscodeStatus = ProcessingStatus.Failed });
+            await SeedAsync(owner, done, pending, failed);
+
+            var result = await CreateHandler().Handle(
+                new GetTracksByUserIdQuery(owner.Id, null, 1, 10, [ProcessingStatus.Pending, ProcessingStatus.Failed]),
+                TestContext.Current.CancellationToken);
+
+            Assert.False(result.IsError);
+            Assert.Equal(["Failed", "Pending"], result.Value.Items.Select(t => t.Title).Order().ToList());
+            Assert.Equal(2, result.Value.TotalItemCount);
+        }
+
+        [Fact]
+        public async Task Handle_NoStatusFilter_ReturnsEveryStatus()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner, TestEntities.Track(owner, "A"), TestEntities.Track(owner, "B", audio: TestEntities.PendingAudio()));
+
+            var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, null, 1, 10), TestContext.Current.CancellationToken);
+
+            Assert.Equal(2, result.Value.TotalItemCount);
+        }
+
+        [Fact]
+        public async Task Handle_ListsActiveAlbumsOfEachTrack()
+        {
+            var owner = TestEntities.User();
+            var track = TestEntities.Track(owner, "Song");
+            var loose = TestEntities.Track(owner, "Loose");
+            var first = TestEntities.Album(owner.Id, "First");
+            var second = TestEntities.Album(owner.Id, "Second");
+            var removed = TestEntities.Album(owner.Id, "Gone");
+            removed.LifeCycleStatus = LifeCycleStatus.Removing;
+            await SeedAsync(
+                owner, track, loose, first, second, removed,
+                new AlbumHasTrack { AlbumId = first.Id, TrackId = track.Id },
+                new AlbumHasTrack { AlbumId = second.Id, TrackId = track.Id },
+                new AlbumHasTrack { AlbumId = removed.Id, TrackId = track.Id });
+
+            var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, null, 1, 10), TestContext.Current.CancellationToken);
+
+            var song = result.Value.Items.Single(t => t.Title == "Song");
+            Assert.Equal(["First", "Second"], song.Albums.Select(a => a.Title).Order().ToList());
+            Assert.Contains(song.Albums, a => a.Id == first.Id);
+            Assert.Empty(result.Value.Items.Single(t => t.Title == "Loose").Albums);
+        }
+
+        [Fact]
+        public async Task Handle_Paginates()
+        {
+            var owner = TestEntities.User();
+            await SeedAsync(owner, TestEntities.Track(owner, "A"), TestEntities.Track(owner, "B"), TestEntities.Track(owner, "C"));
+
+            var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, null, 2, 2), TestContext.Current.CancellationToken);
+
+            Assert.Single(result.Value.Items);
+            Assert.Equal(3, result.Value.TotalItemCount);
+            Assert.True(result.Value.HasPreviousPage);
+        }
+    }
+}