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.
This commit is contained in:
@@ -0,0 +1,35 @@
|
||||
using ErrorOr;
|
||||
using Mediator;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Musify.Application.Albums.Responses;
|
||||
using Musify.Application.Contracts;
|
||||
using Musify.Application.Shared;
|
||||
using Musify.Domain.ValueObjects;
|
||||
|
||||
namespace Musify.Application.Albums
|
||||
{
|
||||
public record GetAlbumTrackIdsQuery(long UserId, Guid AlbumId)
|
||||
: IQuery<ErrorOr<AlbumTrackIdsResponse>>;
|
||||
|
||||
public class GetAlbumTrackIdsQueryHandler(IDatabase database)
|
||||
: IQueryHandler<GetAlbumTrackIdsQuery, ErrorOr<AlbumTrackIdsResponse>>
|
||||
{
|
||||
public async ValueTask<ErrorOr<AlbumTrackIdsResponse>> Handle(GetAlbumTrackIdsQuery request, CancellationToken cancellationToken)
|
||||
{
|
||||
var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
|
||||
if (found.IsError)
|
||||
return found.Errors;
|
||||
|
||||
var trackIds = await database.AlbumHasTracks
|
||||
.AsNoTracking()
|
||||
.Where(albumTrack => albumTrack.AlbumId == request.AlbumId
|
||||
&& albumTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
|
||||
.OrderBy(albumTrack => albumTrack.TrackNumber)
|
||||
.ThenBy(albumTrack => albumTrack.Id)
|
||||
.Select(albumTrack => albumTrack.TrackId)
|
||||
.ToListAsync(cancellationToken);
|
||||
|
||||
return new AlbumTrackIdsResponse(trackIds);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
namespace Musify.Application.Albums.Responses
|
||||
{
|
||||
public record AlbumTrackIdsResponse(IReadOnlyList<Guid> TrackIds);
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
using ErrorOr;
|
||||
using Mediator;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Musify.Application.Contracts;
|
||||
using Musify.Application.Events;
|
||||
using Musify.Application.Shared;
|
||||
using Musify.Application.Tracks.Responses;
|
||||
using Musify.Domain.ValueObjects;
|
||||
|
||||
namespace Musify.Application.Tracks
|
||||
{
|
||||
public record DeleteTracksCommand(long UserId, IReadOnlyList<Guid> TrackIds)
|
||||
: ICommand<ErrorOr<DeleteTracksResponse>>;
|
||||
|
||||
public class DeleteTracksCommandHandler(
|
||||
IDatabase database,
|
||||
IEventBus eventBus,
|
||||
ILogger<DeleteTracksCommandHandler> logger)
|
||||
: ICommandHandler<DeleteTracksCommand, ErrorOr<DeleteTracksResponse>>
|
||||
{
|
||||
public async ValueTask<ErrorOr<DeleteTracksResponse>> Handle(DeleteTracksCommand request, CancellationToken cancellationToken)
|
||||
{
|
||||
var requestedIds = request.TrackIds.Distinct().ToList();
|
||||
|
||||
var tracks = await database.Tracks
|
||||
.Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
|
||||
.ToListAsync(cancellationToken);
|
||||
|
||||
var foreign = tracks.FirstOrDefault(track => track.OwnerUserId != request.UserId);
|
||||
if (foreign != null)
|
||||
return AppErrors.Forbidden("Track", foreign.Id);
|
||||
|
||||
var deleted = new List<Guid>();
|
||||
var failed = new List<Guid>();
|
||||
|
||||
foreach (var trackId in requestedIds)
|
||||
{
|
||||
var track = tracks.SingleOrDefault(candidate => candidate.Id == trackId);
|
||||
if (track == null || track.Audio.IsInProgress)
|
||||
{
|
||||
failed.Add(trackId);
|
||||
continue;
|
||||
}
|
||||
|
||||
track.LifeCycleStatus = LifeCycleStatus.Removing;
|
||||
await eventBus.PublishAsync(new DeleteTrackEvent(track.Id, request.UserId), cancellationToken);
|
||||
deleted.Add(trackId);
|
||||
}
|
||||
|
||||
if (deleted.Count > 0)
|
||||
{
|
||||
await database.SaveChangesAsync(cancellationToken);
|
||||
logger.LogInformation("Marked {Count} tracks of user {UserId} as removing", deleted.Count, request.UserId);
|
||||
}
|
||||
|
||||
return new DeleteTracksResponse(deleted, failed);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
using Mediator;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Musify.Application.Contracts;
|
||||
using Musify.Application.Tracks.Responses;
|
||||
using Musify.Domain.ValueObjects;
|
||||
|
||||
namespace Musify.Application.Tracks
|
||||
{
|
||||
public record GetTrackStatusCountsQuery(long UserId)
|
||||
: IQuery<TrackStatusCountsResponse>;
|
||||
|
||||
public class GetTrackStatusCountsQueryHandler(IDatabase database)
|
||||
: IQueryHandler<GetTrackStatusCountsQuery, TrackStatusCountsResponse>
|
||||
{
|
||||
public async ValueTask<TrackStatusCountsResponse> Handle(GetTrackStatusCountsQuery request, CancellationToken cancellationToken)
|
||||
{
|
||||
var counts = await database.Tracks
|
||||
.AsNoTracking()
|
||||
.Active()
|
||||
.Where(track => track.OwnerUserId == request.UserId)
|
||||
.GroupBy(track => track.Audio.TranscodeStatus)
|
||||
.Select(group => new { Status = group.Key, Count = group.Count() })
|
||||
.ToListAsync(cancellationToken);
|
||||
|
||||
int CountOf(ProcessingStatus status) => counts.Where(c => c.Status == status).Sum(c => c.Count);
|
||||
|
||||
return new TrackStatusCountsResponse(
|
||||
counts.Sum(c => c.Count),
|
||||
CountOf(ProcessingStatus.Pending),
|
||||
CountOf(ProcessingStatus.Processing),
|
||||
CountOf(ProcessingStatus.Completed),
|
||||
CountOf(ProcessingStatus.Failed));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@ using Microsoft.EntityFrameworkCore;
|
||||
using Musify.Application.Contracts;
|
||||
using Musify.Application.Shared;
|
||||
using Musify.Application.Tracks.Responses;
|
||||
using Musify.Domain.ValueObjects;
|
||||
|
||||
namespace Musify.Application.Tracks
|
||||
{
|
||||
@@ -11,13 +12,14 @@ namespace Musify.Application.Tracks
|
||||
long UserId,
|
||||
string? Name,
|
||||
int PageNumber,
|
||||
int PageSize)
|
||||
: IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
|
||||
int PageSize,
|
||||
IReadOnlyList<ProcessingStatus>? Statuses = null)
|
||||
: IQuery<ErrorOr<PaginatedResponse<UserTrackApplicationResponse>>>;
|
||||
|
||||
public class GetTracksByUserIdQueryHandler(IDatabase database)
|
||||
: IQueryHandler<GetTracksByUserIdQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
|
||||
: IQueryHandler<GetTracksByUserIdQuery, ErrorOr<PaginatedResponse<UserTrackApplicationResponse>>>
|
||||
{
|
||||
public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetTracksByUserIdQuery request, CancellationToken cancellationToken)
|
||||
public async ValueTask<ErrorOr<PaginatedResponse<UserTrackApplicationResponse>>> Handle(GetTracksByUserIdQuery request, CancellationToken cancellationToken)
|
||||
{
|
||||
var tracksQuery = database.Tracks
|
||||
.AsNoTracking()
|
||||
@@ -30,10 +32,16 @@ namespace Musify.Application.Tracks
|
||||
tracksQuery = tracksQuery.Where(track => track.NormalizedTitle.Contains(normalizedName));
|
||||
}
|
||||
|
||||
if (request.Statuses is { Count: > 0 } statuses)
|
||||
{
|
||||
var statusList = statuses.Distinct().ToList();
|
||||
tracksQuery = tracksQuery.Where(track => statusList.Contains(track.Audio.TranscodeStatus));
|
||||
}
|
||||
|
||||
return await tracksQuery
|
||||
.OrderByDescending(track => track.CreatedAt)
|
||||
.ThenBy(track => track.Id)
|
||||
.SelectResponse()
|
||||
.SelectUserResponse()
|
||||
.ToPaginatedAsync(new PageRequest(request.PageNumber, request.PageSize), cancellationToken);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
namespace Musify.Application.Tracks.Responses
|
||||
{
|
||||
public record DeleteTracksResponse(
|
||||
IReadOnlyList<Guid> DeletedTrackIds,
|
||||
IReadOnlyList<Guid> FailedTrackIds);
|
||||
}
|
||||
@@ -21,5 +21,25 @@ namespace Musify.Application.Tracks.Responses
|
||||
track.OwnerUserId,
|
||||
track.Tags.Select(tag => tag.Tag).ToList(),
|
||||
track.IsExplicit));
|
||||
|
||||
public static IQueryable<UserTrackApplicationResponse> SelectUserResponse(this IQueryable<Track> query) =>
|
||||
query.Select(track => new UserTrackApplicationResponse(
|
||||
track.Id,
|
||||
track.Title,
|
||||
track.Owner.Name,
|
||||
track.Audio.TranscodeStatus,
|
||||
track.DurationSeconds,
|
||||
track.ListeningHistories.Count(listen => listen.IsCounted),
|
||||
track.CreatedAt,
|
||||
track.UpdatedAt,
|
||||
track.OwnerUserId,
|
||||
track.Tags.Select(tag => tag.Tag).ToList(),
|
||||
track.IsExplicit,
|
||||
track.AlbumTracks
|
||||
.Where(albumTrack => albumTrack.Album.LifeCycleStatus == LifeCycleStatus.Active)
|
||||
.OrderBy(albumTrack => albumTrack.AddedAt)
|
||||
.ThenBy(albumTrack => albumTrack.AlbumId)
|
||||
.Select(albumTrack => new TrackAlbumReference(albumTrack.AlbumId, albumTrack.Album.Title))
|
||||
.ToList()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
namespace Musify.Application.Tracks.Responses
|
||||
{
|
||||
public record TrackStatusCountsResponse(
|
||||
int Total,
|
||||
int Pending,
|
||||
int Processing,
|
||||
int Completed,
|
||||
int Failed);
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
using Musify.Domain.ValueObjects;
|
||||
|
||||
namespace Musify.Application.Tracks.Responses
|
||||
{
|
||||
public record TrackAlbumReference(Guid Id, string Title);
|
||||
|
||||
public record UserTrackApplicationResponse(
|
||||
Guid Id,
|
||||
string Title,
|
||||
string? Artist,
|
||||
ProcessingStatus AudioStatus,
|
||||
double Duration,
|
||||
int ListensCount,
|
||||
DateTime CreatedAt,
|
||||
DateTime UpdatedAt,
|
||||
long OwnerUserId,
|
||||
IReadOnlyCollection<Genre> Tags,
|
||||
bool IsExplicit,
|
||||
IReadOnlyList<TrackAlbumReference> Albums);
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
namespace Musify.Api.DataTransferObjects.Tracks
|
||||
{
|
||||
public record DeleteTracksRequest(IReadOnlyList<Guid> TrackIds);
|
||||
}
|
||||
@@ -57,6 +57,15 @@ namespace Musify.Api.Endpoints
|
||||
.Produces<PaginatedResponse<TrackApplicationResponse>>()
|
||||
.Produces(StatusCodes.Status404NotFound);
|
||||
|
||||
group.MapGet("/{id:guid}/tracks/ids", GetAlbumTrackIds)
|
||||
.WithName("GetAlbumTrackIds")
|
||||
.WithSummary("Get the ids of every track in one of your albums, ordered by track number")
|
||||
.RequireAuthorization()
|
||||
.Produces<AlbumTrackIdsResponse>()
|
||||
.Produces(StatusCodes.Status401Unauthorized)
|
||||
.Produces(StatusCodes.Status403Forbidden)
|
||||
.Produces(StatusCodes.Status404NotFound);
|
||||
|
||||
group.MapGet("/{id:guid}/cover", GetAlbumCover)
|
||||
.WithName("GetAlbumCover")
|
||||
.WithSummary("Get an album cover image")
|
||||
@@ -195,6 +204,16 @@ namespace Musify.Api.Endpoints
|
||||
return result.ToHttpResult();
|
||||
}
|
||||
|
||||
private static async Task<IResult> GetAlbumTrackIds(
|
||||
IMediator mediator,
|
||||
CurrentUser currentUser,
|
||||
Guid id,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var result = await mediator.Send(new GetAlbumTrackIdsQuery(currentUser.RequiredId, id), cancellationToken);
|
||||
return result.ToHttpResult();
|
||||
}
|
||||
|
||||
private static Task<IResult> GetAlbumCover(
|
||||
IMediator mediator,
|
||||
IStorageService storageService,
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
using Mediator;
|
||||
using Microsoft.AspNetCore.Mvc;
|
||||
using Musify.Api.Authentication;
|
||||
using Musify.Api.DataTransferObjects.Tracks;
|
||||
using Musify.Api.Extensions;
|
||||
@@ -9,6 +10,7 @@ using Musify.Application.Pictures;
|
||||
using Musify.Application.Shared;
|
||||
using Musify.Application.Tracks;
|
||||
using Musify.Application.Tracks.Responses;
|
||||
using Musify.Domain.ValueObjects;
|
||||
|
||||
namespace Musify.Api.Endpoints
|
||||
{
|
||||
@@ -57,8 +59,16 @@ namespace Musify.Api.Endpoints
|
||||
group.MapGet("/users/{userId:long}", GetTracksByUserId)
|
||||
.AddEndpointFilter<ValidationFilter<PageQuery>>()
|
||||
.WithName("GetTracksByUserId")
|
||||
.WithSummary("Get paginated tracks for a user")
|
||||
.Produces<PaginatedResponse<TrackApplicationResponse>>();
|
||||
.WithSummary("Get paginated tracks for a user, optionally filtered by name and audio processing status. Each track lists the albums it belongs to")
|
||||
.Produces<PaginatedResponse<UserTrackApplicationResponse>>();
|
||||
|
||||
group.MapGet("/users/{userId:long}/status-counts", GetTrackStatusCounts)
|
||||
.WithName("GetTrackStatusCounts")
|
||||
.WithSummary("Get how many of your tracks are in each audio processing status")
|
||||
.RequireAuthorization()
|
||||
.Produces<TrackStatusCountsResponse>()
|
||||
.Produces(StatusCodes.Status401Unauthorized)
|
||||
.Produces(StatusCodes.Status403Forbidden);
|
||||
|
||||
group.MapPost("/", CreateTrack)
|
||||
.WithName("CreateTrack")
|
||||
@@ -81,6 +91,16 @@ namespace Musify.Api.Endpoints
|
||||
.Produces(StatusCodes.Status404NotFound)
|
||||
.Produces(StatusCodes.Status409Conflict);
|
||||
|
||||
group.MapDelete("/", DeleteTracks)
|
||||
.WithName("DeleteTracks")
|
||||
.WithSummary("Delete several of your tracks at once. Tracks that are missing or still processing are returned as failed")
|
||||
.AddEndpointFilter<ValidationFilter<DeleteTracksRequest>>()
|
||||
.RequireAuthorization()
|
||||
.Produces<DeleteTracksResponse>()
|
||||
.ProducesValidationProblem()
|
||||
.Produces(StatusCodes.Status401Unauthorized)
|
||||
.Produces(StatusCodes.Status403Forbidden);
|
||||
|
||||
group.MapPost("/upload-urls", RequestTrackUploadUrls)
|
||||
.WithName("RequestTrackUploadUrls")
|
||||
.WithSummary("Request pre-signed URLs to upload track picture and audio")
|
||||
@@ -154,9 +174,35 @@ namespace Musify.Api.Endpoints
|
||||
long userId,
|
||||
string? name,
|
||||
[AsParameters] PageQuery page,
|
||||
CancellationToken cancellationToken,
|
||||
ProcessingStatus[]? status = null)
|
||||
{
|
||||
var result = await mediator.Send(
|
||||
new GetTracksByUserIdQuery(userId, name, page.PageNumber, page.PageSize, status),
|
||||
cancellationToken);
|
||||
return result.ToHttpResult();
|
||||
}
|
||||
|
||||
private static async Task<IResult> GetTrackStatusCounts(
|
||||
IMediator mediator,
|
||||
CurrentUser currentUser,
|
||||
long userId,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var result = await mediator.Send(new GetTracksByUserIdQuery(userId, name, page.PageNumber, page.PageSize), cancellationToken);
|
||||
if (currentUser.RequiredId != userId)
|
||||
return Results.Problem("You can only read the status counts of your own tracks.", statusCode: StatusCodes.Status403Forbidden);
|
||||
|
||||
var result = await mediator.Send(new GetTrackStatusCountsQuery(userId), cancellationToken);
|
||||
return Results.Ok(result);
|
||||
}
|
||||
|
||||
private static async Task<IResult> DeleteTracks(
|
||||
IMediator mediator,
|
||||
CurrentUser currentUser,
|
||||
[FromBody] DeleteTracksRequest request,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var result = await mediator.Send(new DeleteTracksCommand(currentUser.RequiredId, request.TrackIds), cancellationToken);
|
||||
return result.ToHttpResult();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
using FluentValidation;
|
||||
using Musify.Api.DataTransferObjects.Tracks;
|
||||
|
||||
namespace Musify.Api.Validators.Tracks
|
||||
{
|
||||
public sealed class DeleteTracksRequestValidator : AbstractValidator<DeleteTracksRequest>
|
||||
{
|
||||
public const int MaxTracksPerRequest = 100;
|
||||
|
||||
public DeleteTracksRequestValidator()
|
||||
{
|
||||
RuleFor(x => x.TrackIds)
|
||||
.NotEmpty()
|
||||
.Must(ids => ids.Count <= MaxTracksPerRequest)
|
||||
.WithMessage($"At most {MaxTracksPerRequest} tracks can be deleted at once.");
|
||||
|
||||
RuleForEach(x => x.TrackIds)
|
||||
.NotEmpty();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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>());
|
||||
}
|
||||
}
|
||||
}
|
||||
+45
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
+79
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user