NotS1mp/Musify
0
0
Fork 0
Code Issues 23 Pull Requests Actions Packages Projects Releases Wiki Activity

Separate responsibilities: start-listening command, API-side JSON converters, bulk track endpoints, mix kinds

Browse Source
This commit is contained in:
Admin
2026-09-24 12:14:53 +02:00
parent 75d0c0817e
commit 0fa033faff
64 changed files with 2903 additions and 651 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/Core/Musify.Application/Albums/AddTrackToAlbum.cs
-58
View File
@@ -1,58 +0,0 @@
using ErrorOr;
using Mediator;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Musify.Application.Contracts;
using Musify.Application.Shared;
using Musify.Domain.Entities;
namespace Musify.Application.Albums;
public record AddTrackToAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
: ICommand<ErrorOr<Success>>;
public class AddTrackToAlbumCommandHandler(
IDatabase database,
ILogger<AddTrackToAlbumCommandHandler> logger)
: ICommandHandler<AddTrackToAlbumCommand, ErrorOr<Success>>
{
public async ValueTask<ErrorOr<Success>> Handle(AddTrackToAlbumCommand request, CancellationToken cancellationToken)
{
var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
if (album.IsError)
return album.Errors;
var track = await database.Tracks.FindOwnedAsync(request.TrackId, request.UserId, cancellationToken);
if (track.IsError)
return track.Errors;
var alreadyAdded = await database.AlbumHasTracks
.AsNoTracking()
.AnyAsync(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.TrackId == request.TrackId, cancellationToken);
if (alreadyAdded)
return AlreadyInAlbum;
// Album track numbers are user-visible, so they start at 1.
var nextTrackNumber = (await database.AlbumHasTracks
.Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
.MaxAsync(albumTrack => (int?)albumTrack.TrackNumber, cancellationToken) ?? 0) + 1;
await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
{
AlbumId = request.AlbumId,
TrackId = request.TrackId,
TrackNumber = nextTrackNumber
}, cancellationToken);
var saved = await database.TrySaveChangesAsync(AlreadyInAlbum, cancellationToken);
if (saved.IsError)
return saved;
logger.LogInformation("Added track {TrackId} to album {AlbumId} as number {TrackNumber}",
request.TrackId, request.AlbumId, nextTrackNumber);
return Result.Success;
}
private static Error AlreadyInAlbum => AppErrors.Conflict("Album.TrackAlreadyAdded", "Track is already in the album.");
}
backend/Core/Musify.Application/Albums/AddTracksToAlbum.cs
+77
View File
@@ -0,0 +1,77 @@
using ErrorOr;
using Mediator;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Musify.Application.Contracts;
using Musify.Application.Shared;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
namespace Musify.Application.Albums;
/// <summary>Appends your own tracks to an album in the given order, skipping the ones it already has.</summary>
public record AddTracksToAlbumCommand(long UserId, Guid AlbumId, IReadOnlyList<Guid> TrackIds)
: ICommand<ErrorOr<Success>>;
public class AddTracksToAlbumCommandHandler(
IDatabase database,
ILogger<AddTracksToAlbumCommandHandler> logger)
: ICommandHandler<AddTracksToAlbumCommand, ErrorOr<Success>>
{
public async ValueTask<ErrorOr<Success>> Handle(AddTracksToAlbumCommand request, CancellationToken cancellationToken)
{
var album = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
if (album.IsError)
return album.Errors;
var requestedIds = request.TrackIds.Distinct().ToList();
var tracks = await database.Tracks
.AsNoTracking()
.Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
.Select(track => new { track.Id, track.OwnerUserId })
.ToListAsync(cancellationToken);
var missing = requestedIds.FirstOrDefault(id => tracks.All(track => track.Id != id));
if (missing != Guid.Empty)
return AppErrors.NotFound("Track", missing);
var foreign = tracks.FirstOrDefault(track => track.OwnerUserId != request.UserId);
if (foreign != null)
return AppErrors.Forbidden("Track", foreign.Id);
var alreadyInAlbum = await database.AlbumHasTracks
.AsNoTracking()
.Where(link => link.AlbumId == request.AlbumId && requestedIds.Contains(link.TrackId))
.Select(link => link.TrackId)
.ToListAsync(cancellationToken);
var toAdd = requestedIds.Where(id => !alreadyInAlbum.Contains(id)).ToList();
if (toAdd.Count == 0)
return Result.Success;
// Album track numbers are user-visible, so they start at 1.
var nextTrackNumber = (await database.AlbumHasTracks
.Where(link => link.AlbumId == request.AlbumId)
.MaxAsync(link => (int?)link.TrackNumber, cancellationToken) ?? 0) + 1;
foreach (var trackId in toAdd)
{
await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
{
AlbumId = request.AlbumId,
TrackId = trackId,
TrackNumber = nextTrackNumber++
}, cancellationToken);
}
var saved = await database.TrySaveChangesAsync(
AppErrors.Conflict("Album.ConcurrentChange", "The album changed while adding tracks. Try again."), cancellationToken);
if (saved.IsError)
return saved;
logger.LogInformation("Added {Count} tracks to album {AlbumId}", toAdd.Count, request.AlbumId);
return Result.Success;
}
}
backend/Core/Musify.Application/Albums/Responses/AlbumApplicationResponse.cs
+1 -3
View File
@@ -1,5 +1,3 @@
using System.Text.Json.Serialization;
using Musify.Application.Serialization;
using Musify.Domain.Entities;
namespace Musify.Application.Albums.Responses;
@@ -9,7 +7,7 @@ public record AlbumApplicationResponse(
string Title,
string? Description,
int? ReleaseYear,
[property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
long OwnerUserId,
int TrackCount,
string? SmallImageKeyName,
string? MediumImageKeyName,
backend/Core/Musify.Application/Contracts/IDatabase.cs
-2
View File
@@ -16,8 +16,6 @@ public interface IDatabase
public DbSet<Track> Tracks { get; }
public DbSet<UserHasTrack> UserHasTracks { get; }
public DbSet<PlayListHasTrack> PlayListHasTracks { get; }
public DbSet<Mix> Mixes { get; }
backend/Core/Musify.Application/Genres/GetGenres.cs
+1 -1
View File
@@ -15,7 +15,7 @@ public class GetGenresQueryHandler(IDatabase database)
{
var rows = await database.TrackTags
.AsNoTracking()
.Where(tag => database.UserHasTracks.Any(userTrack => userTrack.TrackId == tag.TrackId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active))
.Where(tag => tag.Track.LifeCycleStatus == LifeCycleStatus.Active)
.GroupBy(tag => tag.Tag)
.Select(group => new { Genre = group.Key, TrackCount = group.Select(tag => tag.TrackId).Distinct().Count() })
.ToListAsync(cancellationToken);
backend/Core/Musify.Application/Mixes/GenerateMixesForUser.cs
+7 -20
View File
@@ -18,16 +18,16 @@ public class GenerateMixesForUserCommandHandler(
ILogger<GenerateMixesForUserCommandHandler> logger)
: ICommandHandler<GenerateMixesForUserCommand, ErrorOr<Success>>
{
private sealed record MixDraft(string Title, string? Subtitle, IReadOnlyList<Guid> TrackIds);
private sealed record MixDraft(MixKind Kind, IReadOnlyList<Guid> TrackIds);
public async ValueTask<ErrorOr<Success>> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
{
var userId = request.UserId;
var libraryTrackIds = await database.UserHasTracks
var libraryTrackIds = await database.Tracks
.AsNoTracking()
.Where(userTrack => userTrack.UserId == userId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
.Select(userTrack => userTrack.TrackId)
.Where(track => track.OwnerUserId == userId && track.LifeCycleStatus == LifeCycleStatus.Active)
.Select(track => track.Id)
.ToListAsync(cancellationToken);
if (libraryTrackIds.Count == 0)
@@ -51,19 +51,13 @@ public class GenerateMixesForUserCommandHandler(
var discovery = Take(Shuffle(unheardTrackIds));
if (discovery.Count > 0)
{
drafts.Add(new MixDraft(
"Descubrimiento",
"Canciones de tu biblioteca que todavía no has escuchado.",
discovery));
drafts.Add(new MixDraft(MixKind.Discovery, discovery));
}
var daily = Take(Interleave(Shuffle(historyTrackIds), Shuffle(unheardTrackIds)));
if (daily.Count > 0)
{
drafts.Add(new MixDraft(
"Tu mezcla diaria",
"Lo que más escuchas, con alguna sorpresa de tu biblioteca.",
daily));
drafts.Add(new MixDraft(MixKind.Daily, daily));
}
if (drafts.Count == 0)
@@ -108,12 +102,6 @@ public class GenerateMixesForUserCommandHandler(
if (previousMixes.Count > 0)
{
var previousIds = previousMixes.Select(mix => mix.Id).ToList();
var previousItems = await database.MixItems
.Where(item => previousIds.Contains(item.MixId))
.ToListAsync(cancellationToken);
database.MixItems.RemoveRange(previousItems);
database.Mixes.RemoveRange(previousMixes);
}
@@ -123,8 +111,7 @@ public class GenerateMixesForUserCommandHandler(
var mix = new Mix
{
UserId = userId,
Title = draft.Title,
Subtitle = draft.Subtitle,
Kind = draft.Kind,
Position = position
};
backend/Core/Musify.Application/Mixes/GetMixById.cs
+1 -1
View File
@@ -26,6 +26,6 @@ public class GetMixByIdQueryHandler(IDatabase database)
var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
var items = await MixItemMapper.ToResponsesAsync(database, orderedItems, cancellationToken);
return new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, items.Count, items);
return new MixApplicationResponse(mix.Id, mix.Kind, items.Count, items);
}
}
backend/Core/Musify.Application/Mixes/GetMixesByUserId.cs
+1 -1
View File
@@ -42,7 +42,7 @@ public class GetMixesByUserIdQueryHandler(IDatabase database)
.Select(item => coverResponses[item.TrackId])
.ToList();
responses.Add(new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, orderedItems.Count, covers));
responses.Add(new MixApplicationResponse(mix.Id, mix.Kind, orderedItems.Count, covers));
}
return responses;
backend/Core/Musify.Application/Mixes/Responses/MixApplicationResponse.cs
+3 -2
View File
@@ -1,9 +1,10 @@
using Musify.Domain.ValueObjects;
namespace Musify.Application.Mixes.Responses;
public record MixApplicationResponse(
Guid Id,
string Title,
string? Subtitle,
MixKind Kind,
int ItemCount,
IReadOnlyList<MixItemApplicationResponse> Items)
{
backend/Core/Musify.Application/PlayLists/AddTrackToPlayList.cs
-61
View File
@@ -1,61 +0,0 @@
using ErrorOr;
using Mediator;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Musify.Application.Contracts;
using Musify.Application.Shared;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
namespace Musify.Application.PlayLists;
public record AddTrackToPlayListCommand(long UserId, Guid PlayListId, Guid TrackId)
: ICommand<ErrorOr<Success>>;
public class AddTrackToPlayListCommandHandler(
IDatabase database,
ILogger<AddTrackToPlayListCommandHandler> logger)
: ICommandHandler<AddTrackToPlayListCommand, ErrorOr<Success>>
{
public async ValueTask<ErrorOr<Success>> Handle(AddTrackToPlayListCommand request, CancellationToken cancellationToken)
{
var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
if (playList.IsError)
return playList.Errors;
var trackExists = await database.Tracks
.AsNoTracking()
.AnyAsync(t => t.Id == request.TrackId && t.LifeCycleStatus == LifeCycleStatus.Active, cancellationToken);
if (!trackExists)
return AppErrors.NotFound("Track", request.TrackId);
var alreadyAdded = await database.PlayListHasTracks
.AsNoTracking()
.AnyAsync(plt => plt.PlayListId == request.PlayListId && plt.TrackId == request.TrackId, cancellationToken);
if (alreadyAdded)
return AlreadyInPlayList;
// Playlist positions are internal indexes, so they start at 0.
var nextPosition = (await database.PlayListHasTracks
.Where(plt => plt.PlayListId == request.PlayListId)
.MaxAsync(plt => (int?)plt.Position, cancellationToken) ?? -1) + 1;
await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
{
PlayListId = request.PlayListId,
TrackId = request.TrackId,
Position = nextPosition
}, cancellationToken);
var saved = await database.TrySaveChangesAsync(AlreadyInPlayList, cancellationToken);
if (saved.IsError)
return saved;
logger.LogInformation("Added track {TrackId} to playlist {PlayListId} at position {Position}",
request.TrackId, request.PlayListId, nextPosition);
return Result.Success;
}
private static Error AlreadyInPlayList => AppErrors.Conflict("PlayList.TrackAlreadyAdded", "Track is already in the playlist.");
}
backend/Core/Musify.Application/PlayLists/AddTracksToPlayList.cs
+73
View File
@@ -0,0 +1,73 @@
using ErrorOr;
using Mediator;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Musify.Application.Contracts;
using Musify.Application.Shared;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
namespace Musify.Application.PlayLists;
/// <summary>Appends tracks to a playlist in the given order, skipping the ones it already has.</summary>
public record AddTracksToPlayListCommand(long UserId, Guid PlayListId, IReadOnlyList<Guid> TrackIds)
: ICommand<ErrorOr<Success>>;
public class AddTracksToPlayListCommandHandler(
IDatabase database,
ILogger<AddTracksToPlayListCommandHandler> logger)
: ICommandHandler<AddTracksToPlayListCommand, ErrorOr<Success>>
{
public async ValueTask<ErrorOr<Success>> Handle(AddTracksToPlayListCommand request, CancellationToken cancellationToken)
{
var playList = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
if (playList.IsError)
return playList.Errors;
var requestedIds = request.TrackIds.Distinct().ToList();
var existingIds = await database.Tracks
.AsNoTracking()
.Where(track => requestedIds.Contains(track.Id) && track.LifeCycleStatus == LifeCycleStatus.Active)
.Select(track => track.Id)
.ToListAsync(cancellationToken);
var missing = requestedIds.FirstOrDefault(id => !existingIds.Contains(id));
if (missing != Guid.Empty)
return AppErrors.NotFound("Track", missing);
var alreadyInPlayList = await database.PlayListHasTracks
.AsNoTracking()
.Where(link => link.PlayListId == request.PlayListId && requestedIds.Contains(link.TrackId))
.Select(link => link.TrackId)
.ToListAsync(cancellationToken);
var toAdd = requestedIds.Where(id => !alreadyInPlayList.Contains(id)).ToList();
if (toAdd.Count == 0)
return Result.Success;
// Playlist positions are internal indexes, so they start at 0.
var nextPosition = (await database.PlayListHasTracks
.Where(link => link.PlayListId == request.PlayListId)
.MaxAsync(link => (int?)link.Position, cancellationToken) ?? -1) + 1;
foreach (var trackId in toAdd)
{
await database.PlayListHasTracks.AddAsync(new PlayListHasTrack
{
PlayListId = request.PlayListId,
TrackId = trackId,
Position = nextPosition++
}, cancellationToken);
}
var saved = await database.TrySaveChangesAsync(
AppErrors.Conflict("PlayList.ConcurrentChange", "The playlist changed while adding tracks. Try again."), cancellationToken);
if (saved.IsError)
return saved;
logger.LogInformation("Added {Count} tracks to playlist {PlayListId}", toAdd.Count, request.PlayListId);
return Result.Success;
}
}
backend/Core/Musify.Application/PlayLists/Responses/PlayListApplicationResponse.cs
+1 -3
View File
@@ -1,8 +1,6 @@
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
using System.Text.Json.Serialization;
using Musify.Application.Serialization;
namespace Musify.Application.PlayLists.Responses;
@@ -17,7 +15,7 @@ public record PlayListApplicationResponse(
DateTime CreatedAt,
DateTime UpdatedAt,
IReadOnlyList<Guid> CoverTrackIds,
[property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
long OwnerUserId,
int TrackCount,
double DurationSeconds)
{
backend/Core/Musify.Application/Services/TrackStreamIssuer.cs
+3 -24
View File
@@ -1,28 +1,20 @@
using Musify.Application.Configuration;
using Musify.Application.Contracts;
using Musify.Application.Tracks.Responses;
using Musify.Domain.Entities;
namespace Musify.Application.Services;
/// <summary>Builds the stream URL and signed ticket for a processed track. It never touches the database.</summary>
public sealed class TrackStreamIssuer(
IDatabase database,
IStreamTicketService ticketService,
TrackConfiguration trackConfiguration,
StreamGatewayConfiguration streamGatewayConfiguration,
PlaybackConfiguration playbackConfiguration)
{
public async Task<TrackStreamResponse> IssueAsync(
Guid trackId,
string audioFolderName,
long? userId,
CancellationToken cancellationToken)
public TrackStreamResponse Issue(string audioFolderName, long? userId, Guid? listenId)
{
var folderPath = trackConfiguration.Routes.BuildProcessedAudioPath(audioFolderName);
var keyPrefix = $"{folderPath}/";
var maxBytes = AnonymousFragmentBytes(userId);
var ticket = ticketService.IssueTicket(userId, keyPrefix, maxBytes);
var ticket = ticketService.IssueTicket(userId, $"{folderPath}/", AnonymousFragmentBytes(userId));
var manifestUrl = string.Join('/',
streamGatewayConfiguration.PublicBaseUrl.TrimEnd('/'),
@@ -30,19 +22,6 @@ public sealed class TrackStreamIssuer(
folderPath,
streamGatewayConfiguration.AudioFileName);
Guid? listenId = null;
if (userId != null)
{
var newListeningHistory = new ListeningHistory
{
UserId = userId.Value,
TrackId = trackId,
};
await database.ListeningHistories.AddAsync(newListeningHistory, cancellationToken);
await database.SaveChangesAsync(cancellationToken);
listenId = newListeningHistory.Id;
}
return new TrackStreamResponse(manifestUrl, ticket.Token, ticket.ExpiresInSeconds, listenId);
}
backend/Core/Musify.Application/Tracks/CreateTrack.cs
-20
View File
@@ -41,21 +41,6 @@ public class CreateTrackCommandHandler(
}
var distinctTags = request.Tags.Distinct().ToList();
if (distinctTags.Count == 0)
{
logger.LogWarning("Track {Title} was submitted without any tags", request.Title);
return Error.Validation(description: "At least one tag is required.");
}
var tagConflicts = GenreCompatibility.FindConflicts(distinctTags);
if (tagConflicts.Count > 0)
{
var conflict = tagConflicts.First();
logger.LogWarning(
"Track {Title} was submitted with incompatible tags {First} and {Second}",
request.Title, conflict.First, conflict.Second);
return Error.Validation(description: $"Tags '{conflict.First}' and '{conflict.Second}' are not compatible.");
}
if (request.PictureIntentId == request.AudioIntentId)
return Error.Validation(description: "Picture and audio must use different upload intents.");
@@ -105,11 +90,6 @@ public class CreateTrackCommandHandler(
await database.Tracks.AddAsync(trackEntity, cancellationToken);
await database.UserHasTracks.AddAsync(new UserHasTrack
{
UserId = request.UserId,
TrackId = trackEntity.Id
}, cancellationToken);
var sizes = trackConfiguration.PicturesSizes.ToImageSizes(trackConfiguration.Routes);
await eventBus.PublishAsync(
backend/Core/Musify.Application/Tracks/RecordListeningProgress.cs
-3
View File
@@ -17,9 +17,6 @@ public class RecordListeningProgressCommandHandler(IDatabase database)
{
public async ValueTask<ErrorOr<Success>> Handle(RecordListeningProgressCommand request, CancellationToken cancellationToken)
{
if (!double.IsFinite(request.PlayedSeconds) || request.PlayedSeconds < 0)
return Error.Validation(description: "playedSeconds must be a non-negative number.");
var listen = await database.ListeningHistories
.Include(l => l.Track)
.SingleOrDefaultAsync(l => l.Id == request.ListenId && l.UserId == request.UserId, cancellationToken);
backend/Core/Musify.Application/Tracks/Responses/TrackApplicationResponse.cs
+1 -3
View File
@@ -1,5 +1,3 @@
using System.Text.Json.Serialization;
using Musify.Application.Serialization;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
@@ -14,7 +12,7 @@ public record TrackApplicationResponse(
int ListensCount,
DateTime CreatedAt,
DateTime UpdatedAt,
[property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
long OwnerUserId,
IReadOnlyCollection<Genre> Tags,
bool IsExplicit)
{
backend/Core/Musify.Application/Tracks/GetTrackStream.cs → backend/Core/Musify.Application/Tracks/StartListening.cs
+19 -11
View File
@@ -5,24 +5,25 @@ using Microsoft.Extensions.Logging;
using Musify.Application.Configuration;
using Musify.Application.Contracts;
using Musify.Application.Services;
using Musify.Application.Tracks.Responses;
using Musify.Domain.ValueObjects;
using Musify.Application.Shared;
using Musify.Application.Tracks.Responses;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
namespace Musify.Application.Tracks;
/// <summary>Starts a listen: records it for signed-in users and issues the stream ticket.</summary>
public record StartListeningCommand(Guid TrackId, long? UserId)
: ICommand<ErrorOr<TrackStreamResponse>>;
public record GetTrackStreamQuery(Guid TrackId, long? UserId)
: IQuery<ErrorOr<TrackStreamResponse>>;
public class GetTrackStreamQueryHandler(
public class StartListeningCommandHandler(
IDatabase database,
TrackStreamIssuer streamIssuer,
PlaybackConfiguration playbackConfiguration,
ILogger<GetTrackStreamQueryHandler> logger)
: IQueryHandler<GetTrackStreamQuery, ErrorOr<TrackStreamResponse>>
ILogger<StartListeningCommandHandler> logger)
: ICommandHandler<StartListeningCommand, ErrorOr<TrackStreamResponse>>
{
public async ValueTask<ErrorOr<TrackStreamResponse>> Handle(GetTrackStreamQuery request, CancellationToken cancellationToken)
public async ValueTask<ErrorOr<TrackStreamResponse>> Handle(StartListeningCommand request, CancellationToken cancellationToken)
{
if (request.UserId == null && !playbackConfiguration.AllowAnonymousListening)
return Error.Unauthorized(description: "Sign in to stream music, or ask an administrator to enable anonymous listening.");
@@ -38,10 +39,17 @@ public class GetTrackStreamQueryHandler(
if (!track.Audio.IsProcessed)
return AppErrors.Conflict("Track.AudioNotReady", "Track audio is not available for streaming yet.");
var response = await streamIssuer.IssueAsync(track.Id, track.Audio.FolderName, request.UserId, cancellationToken);
Guid? listenId = null;
if (request.UserId is { } userId)
{
var listen = new ListeningHistory { UserId = userId, TrackId = track.Id };
await database.ListeningHistories.AddAsync(listen, cancellationToken);
await database.SaveChangesAsync(cancellationToken);
listenId = listen.Id;
}
logger.LogInformation("Issued stream ticket for track {TrackId} to user {UserId}", request.TrackId, request.UserId?.ToString() ?? "(anonymous)");
return response;
return streamIssuer.Issue(track.Audio.FolderName, request.UserId, listenId);
}
}
backend/Core/Musify.Application/Users/Responses/UserApplicationResponse.cs
+1 -3
View File
@@ -1,11 +1,9 @@
using System.Text.Json.Serialization;
using Musify.Application.Serialization;
using Musify.Domain.Entities;
namespace Musify.Application.Users.Responses;
public record UserApplicationResponse(
[property: JsonConverter(typeof(LongAsStringConverter))] long Id,
long Id,
string Name,
string? FirstName,
string? SecondName,
backend/Core/Musify.Application/Users/Responses/UserProfileResponse.cs
+1 -3
View File
@@ -1,10 +1,8 @@
using System.Text.Json.Serialization;
using Musify.Application.Serialization;
namespace Musify.Application.Users.Responses;
public record UserProfileResponse(
[property: JsonConverter(typeof(LongAsStringConverter))] long Id,
long Id,
string Name,
string? FirstName,
string? SecondName,
backend/Core/Musify.Application/Users/Responses/UserSummaryResponse.cs
+1 -3
View File
@@ -1,10 +1,8 @@
using System.Text.Json.Serialization;
using Musify.Application.Serialization;
namespace Musify.Application.Users.Responses;
public record UserSummaryResponse(
[property: JsonConverter(typeof(LongAsStringConverter))] long Id,
long Id,
string Name,
string? FirstName,
string? SecondName,
backend/Core/Musify.Domain/Entities/Mix.cs
+2 -5
View File
@@ -1,4 +1,5 @@
using System.ComponentModel.DataAnnotations;
using Musify.Domain.ValueObjects;
using System.ComponentModel.DataAnnotations.Schema;
using Musify.Domain.Abstractions;
@@ -13,11 +14,7 @@ public class Mix : IAuditable
public required long UserId { get; set; }
[MaxLength(100)]
public required string Title { get; set; }
[MaxLength(256)]
public string? Subtitle { get; set; }
public MixKind Kind { get; set; }
public int Position { get; set; }
backend/Core/Musify.Domain/Entities/Track.cs
-2
View File
@@ -36,8 +36,6 @@ public class Track : IAuditable, IHasLifeCycle, IOwnedEntity
public TrackAudio Audio { get; set; } = new();
public ICollection<UserHasTrack> UserTracks { get; set; } = new List<UserHasTrack>();
public ICollection<PlayListHasTrack> PlayListTracks { get; set; } = new List<PlayListHasTrack>();
public ICollection<AlbumHasTrack> AlbumTracks { get; set; } = new List<AlbumHasTrack>();
backend/Core/Musify.Domain/Entities/User.cs
-2
View File
@@ -30,8 +30,6 @@ public class User : IAuditable
public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
public ICollection<UserHasTrack> UserTracks { get; set; } = new List<UserHasTrack>();
public ICollection<PlayList> PlayLists { get; set; } = new List<PlayList>();
public ICollection<ListeningHistory> ListeningHistories { get; set; } = new List<ListeningHistory>();
backend/Core/Musify.Domain/Entities/UserHasTrack.cs
-19
View File
@@ -1,19 +0,0 @@
using System.ComponentModel.DataAnnotations.Schema;
namespace Musify.Domain.Entities;
[Table("UserHasTrack")]
public class UserHasTrack
{
public Guid Id { get; set; } = Guid.NewGuid();
public required long UserId { get; set; }
public required Guid TrackId { get; set; }
[ForeignKey(nameof(UserId))]
public User User { get; set; } = null!;
[ForeignKey(nameof(TrackId))]
public Track Track { get; set; } = null!;
}
backend/Core/Musify.Domain/ValueObjects/MixKind.cs
+7
View File
@@ -0,0 +1,7 @@
namespace Musify.Domain.ValueObjects;
public enum MixKind
{
Discovery = 0,
Daily = 1
}
backend/Core/Musify.Infrastructure/Persistence/Database.cs
-2
View File
@@ -181,8 +181,6 @@ public class Database(DatabaseConfiguration configuration)
public DbSet<AlbumHasTrack> AlbumHasTracks => Set<AlbumHasTrack>();
public DbSet<UserHasTrack> UserHasTracks => Set<UserHasTrack>();
public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
public DbSet<Mix> Mixes => Set<Mix>();
backend/Core/Musify.Infrastructure/Persistence/Migrations/20260924101123_DropUserHasTrack.Designer.cs
Generated
+1090
View File
File diff suppressed because it is too large Load Diff
backend/Core/Musify.Infrastructure/Persistence/Migrations/20260924101123_DropUserHasTrack.cs
+57
View File
@@ -0,0 +1,57 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Musify.Infrastructure.Persistence.Migrations
{
/// <inheritdoc />
public partial class DropUserHasTrack : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "UserHasTrack");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "UserHasTrack",
columns: table => new
{
Id = table.Column<Guid>(type: "uuid", nullable: false),
TrackId = table.Column<Guid>(type: "uuid", nullable: false),
UserId = table.Column<long>(type: "bigint", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_UserHasTrack", x => x.Id);
table.ForeignKey(
name: "FK_UserHasTrack_Tracks_TrackId",
column: x => x.TrackId,
principalTable: "Tracks",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_UserHasTrack_User_UserId",
column: x => x.UserId,
principalTable: "User",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateIndex(
name: "IX_UserHasTrack_TrackId",
table: "UserHasTrack",
column: "TrackId");
migrationBuilder.CreateIndex(
name: "IX_UserHasTrack_UserId",
table: "UserHasTrack",
column: "UserId");
}
}
}
backend/Core/Musify.Infrastructure/Persistence/Migrations/20260924101237_MixKind.Designer.cs
Generated
+1084
View File
File diff suppressed because it is too large Load Diff
backend/Core/Musify.Infrastructure/Persistence/Migrations/20260924101237_MixKind.cs
+55
View File
@@ -0,0 +1,55 @@
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Musify.Infrastructure.Persistence.Migrations
{
/// <inheritdoc />
public partial class MixKind : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.AddColumn<int>(
name: "Kind",
table: "Mixes",
type: "integer",
nullable: false,
defaultValue: 0);
// Mixes used to store their Spanish title; the daily mix is kind 1, everything else is discovery.
migrationBuilder.Sql("UPDATE \"Mixes\" SET \"Kind\" = 1 WHERE \"Title\" = 'Tu mezcla diaria';");
migrationBuilder.DropColumn(
name: "Subtitle",
table: "Mixes");
migrationBuilder.DropColumn(
name: "Title",
table: "Mixes");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropColumn(
name: "Kind",
table: "Mixes");
migrationBuilder.AddColumn<string>(
name: "Subtitle",
table: "Mixes",
type: "character varying(256)",
maxLength: 256,
nullable: true);
migrationBuilder.AddColumn<string>(
name: "Title",
table: "Mixes",
type: "character varying(100)",
maxLength: 100,
nullable: false,
defaultValue: "");
}
}
}
backend/Core/Musify.Infrastructure/Persistence/Migrations/DatabaseModelSnapshot.cs
+3 -53
View File
@@ -304,17 +304,11 @@ namespace Musify.Infrastructure.Persistence.Migrations
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<int>("Position")
b.Property<int>("Kind")
.HasColumnType("integer");
b.Property<string>("Subtitle")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("Title")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<int>("Position")
.HasColumnType("integer");
b.Property<DateTime>("UpdatedAt")
.HasColumnType("timestamp with time zone");
@@ -626,27 +620,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
b.ToTable("UserFollows");
});
modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uuid");
b.Property<Guid>("TrackId")
.HasColumnType("uuid");
b.Property<long>("UserId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("TrackId");
b.HasIndex("UserId");
b.ToTable("UserHasTrack");
});
modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.AlbumProcessingState", b =>
{
b.Property<Guid>("CorrelationId")
@@ -1070,25 +1043,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
b.Navigation("Follower");
});
modelBuilder.Entity("Musify.Domain.Entities.UserHasTrack", b =>
{
b.HasOne("Musify.Domain.Entities.Track", "Track")
.WithMany("UserTracks")
.HasForeignKey("TrackId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("Musify.Domain.Entities.User", "User")
.WithMany("UserTracks")
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("Track");
b.Navigation("User");
});
modelBuilder.Entity("Musify.Domain.Entities.Album", b =>
{
b.Navigation("AlbumTracks");
@@ -1113,8 +1067,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
b.Navigation("PlayListTracks");
b.Navigation("Tags");
b.Navigation("UserTracks");
});
modelBuilder.Entity("Musify.Domain.Entities.User", b =>
@@ -1122,8 +1074,6 @@ namespace Musify.Infrastructure.Persistence.Migrations
b.Navigation("ListeningHistories");
b.Navigation("PlayLists");
b.Navigation("UserTracks");
});
#pragma warning restore 612, 618
}
backend/Hosts/Musify.Api/DataTransferObjects/AddTracksRequest.cs
+3
View File
@@ -0,0 +1,3 @@
namespace Musify.Api.DataTransferObjects;
public record AddTracksRequest(IReadOnlyList<Guid> TrackIds);
backend/Hosts/Musify.Api/DataTransferObjects/PlayLists/AddPlayListTrackRequest.cs
-3
View File
@@ -1,3 +0,0 @@
namespace Musify.Api.DataTransferObjects.PlayLists;
public record AddPlayListTrackRequest(Guid TrackId);
backend/Hosts/Musify.Api/Endpoints/AlbumEndpoints.cs
+10 -7
View File
@@ -1,5 +1,6 @@
using Mediator;
using Musify.Api.Authentication;
using Musify.Api.DataTransferObjects;
using Musify.Api.DataTransferObjects.Albums;
using Musify.Api.Extensions;
using Musify.Api.Filters;
@@ -102,11 +103,13 @@ public static class AlbumEndpoints
.Produces(StatusCodes.Status403Forbidden)
.Produces(StatusCodes.Status404NotFound);
group.MapPost("/{albumId}/tracks/{trackId}", AddTrackToAlbum)
.WithName("AddTrackToAlbum")
.WithSummary("Add One Of Your Uploaded Tracks To An Album.")
group.MapPost("/{id}/tracks", AddAlbumTracks)
.WithName("AddAlbumTracks")
.WithSummary("Add Your Uploaded Tracks To An Album, Skipping The Ones It Already Has.")
.AddEndpointFilter<ValidationFilter<AddTracksRequest>>()
.RequireAuthorization()
.Produces(StatusCodes.Status204NoContent)
.ProducesValidationProblem()
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status403Forbidden)
.Produces(StatusCodes.Status404NotFound)
@@ -242,15 +245,15 @@ public static class AlbumEndpoints
return result.ToHttpResult();
}
private static async Task<IResult> AddTrackToAlbum(
private static async Task<IResult> AddAlbumTracks(
IMediator mediator,
CurrentUser currentUser,
Guid albumId,
Guid trackId,
Guid id,
AddTracksRequest request,
CancellationToken cancellationToken)
{
var result = await mediator.Send(
new AddTrackToAlbumCommand(currentUser.RequiredId, albumId, trackId),
new AddTracksToAlbumCommand(currentUser.RequiredId, id, request.TrackIds),
cancellationToken);
return result.ToHttpResult();
backend/Hosts/Musify.Api/Endpoints/PlayListEndpoints.cs
+13 -14
View File
@@ -1,5 +1,6 @@
using Mediator;
using Musify.Api.Authentication;
using Musify.Api.DataTransferObjects;
using Musify.Api.DataTransferObjects.PlayLists;
using Musify.Api.Extensions;
using Musify.Api.Filters;
@@ -10,7 +11,6 @@ using Musify.Application.PlayLists;
using Musify.Application.PlayLists.Responses;
using Musify.Api.Models;
using Musify.Application.Shared;
using Musify.Application.Tracks;
using Musify.Application.Tracks.Responses;
namespace Musify.Api.Endpoints;
@@ -87,11 +87,13 @@ public static class PlayListEndpoints
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status404NotFound);
group.MapPost("/{playlistId}/tracks", AddPlayListTrack)
.WithName("AddPlayListTrack")
.WithSummary("Add One Of Your Tracks To A PlayList.")
group.MapPost("/{id}/tracks", AddPlayListTracks)
.WithName("AddPlayListTracks")
.WithSummary("Add Tracks To A PlayList, Skipping The Ones It Already Has.")
.AddEndpointFilter<ValidationFilter<AddTracksRequest>>()
.RequireAuthorization()
.Produces<TrackApplicationResponse>(StatusCodes.Status201Created)
.Produces(StatusCodes.Status204NoContent)
.ProducesValidationProblem()
.Produces(StatusCodes.Status401Unauthorized)
.Produces(StatusCodes.Status403Forbidden)
.Produces(StatusCodes.Status404NotFound)
@@ -203,21 +205,18 @@ public static class PlayListEndpoints
return result.ToHttpResult();
}
private static async Task<IResult> AddPlayListTrack(
private static async Task<IResult> AddPlayListTracks(
IMediator mediator,
CurrentUser currentUser,
Guid playlistId,
AddPlayListTrackRequest request,
Guid id,
AddTracksRequest request,
CancellationToken cancellationToken)
{
var addResult = await mediator.Send(
new AddTrackToPlayListCommand(currentUser.RequiredId, playlistId, request.TrackId),
var result = await mediator.Send(
new AddTracksToPlayListCommand(currentUser.RequiredId, id, request.TrackIds),
cancellationToken);
if (addResult.IsError)
return addResult.ToHttpResult();
var trackResult = await mediator.Send(new GetTrackByIdQuery(request.TrackId), cancellationToken);
return trackResult.ToCreatedResult(track => $"/tracks/{track.Id}");
return result.ToHttpResult();
}
private static async Task<IResult> RemoveTrackFromPlayList(
backend/Hosts/Musify.Api/Endpoints/TrackEndpoints.cs
+4 -18
View File
@@ -9,7 +9,6 @@ using Musify.Api.Models;
using Musify.Application.Shared;
using Musify.Application.Tracks;
using Musify.Application.Tracks.Responses;
using Musify.Domain.ValueObjects;
namespace Musify.Api.Endpoints;
@@ -47,6 +46,7 @@ public static class TrackEndpoints
.Produces(StatusCodes.Status404NotFound);
group.MapPut("/listens/{listenId}/progress", RecordListeningProgress)
.AddEndpointFilter<ValidationFilter<RecordListeningProgressRequest>>()
.WithName("RecordListeningProgress")
.WithSummary("Report The Total Seconds Actually Played For A Listen Started By The Stream Endpoint.")
.RequireAuthorization()
@@ -99,24 +99,10 @@ public static class TrackEndpoints
IMediator mediator,
CancellationToken cancellationToken,
string? name,
string? genre,
GenreParameter? genre,
[AsParameters] PageQuery page)
{
Genre? parsedGenre = null;
if (!string.IsNullOrWhiteSpace(genre))
{
if (!Enum.TryParse<Genre>(genre, ignoreCase: true, out var value) || !Enum.IsDefined(value))
{
return Results.ValidationProblem(new Dictionary<string, string[]>
{
[nameof(genre)] = [$"'{genre}' is not a valid genre."]
});
}
parsedGenre = value;
}
var result = await mediator.Send(new GetTracksQuery(name, page.PageNumber, page.PageSize, parsedGenre), cancellationToken);
var result = await mediator.Send(new GetTracksQuery(name, page.PageNumber, page.PageSize, genre?.Value), cancellationToken);
return Results.Ok(result);
}
@@ -146,7 +132,7 @@ public static class TrackEndpoints
Guid id,
CancellationToken cancellationToken)
{
var result = await mediator.Send(new GetTrackStreamQuery(id, currentUser.Id), cancellationToken);
var result = await mediator.Send(new StartListeningCommand(id, currentUser.Id), cancellationToken);
return result.ToHttpResult();
}
backend/Hosts/Musify.Api/Models/GenreParameter.cs
+19
View File
@@ -0,0 +1,19 @@
using Musify.Domain.ValueObjects;
namespace Musify.Api.Models;
/// <summary>Query-string binding for a genre name (case-insensitive); unknown names are rejected with a 400.</summary>
public readonly record struct GenreParameter(Genre Value)
{
public static bool TryParse(string? value, out GenreParameter result)
{
if (Enum.TryParse<Genre>(value, ignoreCase: true, out var genre) && Enum.IsDefined(genre))
{
result = new GenreParameter(genre);
return true;
}
result = default;
return false;
}
}
backend/Hosts/Musify.Api/OpenApi/OpenApiOptionsSetup.cs
+9 -4
View File
@@ -3,7 +3,6 @@ using Microsoft.AspNetCore.OpenApi;
using Microsoft.Extensions.Options;
using Microsoft.OpenApi;
using Musify.Api.Authentication;
using Musify.Application.Serialization;
namespace Musify.Api.OpenApi;
@@ -41,10 +40,16 @@ public sealed class OpenApiOptionsSetup(IOptions<AuthenticationConfiguration> op
options.AddSchemaTransformer((schema, context, _) =>
{
if (context.JsonPropertyInfo?.CustomConverter is LongAsStringConverter or NullableLongAsStringConverter)
// Every long the API returns is a user id, serialized as a string (JS loses precision above 2^53).
// Request DTOs only carry byte sizes, which may be sent as numbers or strings.
if (context.JsonPropertyInfo is { } property
&& (property.PropertyType == typeof(long) || property.PropertyType == typeof(long?)))
{
schema.Type = JsonSchemaType.String;
schema.Format = null;
var isRequest = property.DeclaringType?.Name.EndsWith("Request", StringComparison.Ordinal) == true;
schema.Type = isRequest ? JsonSchemaType.Integer | JsonSchemaType.String : JsonSchemaType.String;
if (property.PropertyType == typeof(long?))
schema.Type |= JsonSchemaType.Null;
schema.Format = isRequest ? "int64" : null;
}
return Task.CompletedTask;
backend/Hosts/Musify.Api/Program.cs
+6 -1
View File
@@ -1,13 +1,18 @@
using System.Text.Json.Serialization;
using Musify.Api.Endpoints;
using Musify.Api.Extensions;
using Musify.Api.Serialization;
using Musify.Infrastructure.Observability;
using Scalar.AspNetCore;
var builder = WebApplication.CreateBuilder();
builder.Services.ConfigureHttpJsonOptions(options =>
options.SerializerOptions.Converters.Add(new JsonStringEnumConverter()));
{
options.SerializerOptions.Converters.Add(new JsonStringEnumConverter());
options.SerializerOptions.Converters.Add(new LongAsStringConverter());
options.SerializerOptions.Converters.Add(new NullableLongAsStringConverter());
});
const string devCorsPolicy = "dev-cors";
backend/Core/Musify.Application/Serialization/LongAsStringConverter.cs → backend/Hosts/Musify.Api/Serialization/LongAsStringConverter.cs
+1 -1
View File
@@ -2,7 +2,7 @@ using System.Globalization;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace Musify.Application.Serialization;
namespace Musify.Api.Serialization;
public sealed class LongAsStringConverter : JsonConverter<long>
{
backend/Hosts/Musify.Api/Validators/AddTracksRequestValidator.cs
+20
View File
@@ -0,0 +1,20 @@
using FluentValidation;
using Musify.Api.DataTransferObjects;
namespace Musify.Api.Validators;
public sealed class AddTracksRequestValidator : AbstractValidator<AddTracksRequest>
{
public const int MaxTracksPerRequest = 500;
public AddTracksRequestValidator()
{
RuleFor(x => x.TrackIds)
.NotEmpty()
.Must(ids => ids.Count <= MaxTracksPerRequest)
.WithMessage($"At most {MaxTracksPerRequest} tracks can be added at once.");
RuleForEach(x => x.TrackIds)
.NotEmpty();
}
}
backend/Hosts/Musify.Api/Validators/Tracks/RecordListeningProgressRequestValidator.cs
+14
View File
@@ -0,0 +1,14 @@
using FluentValidation;
using Musify.Api.DataTransferObjects.Tracks;
namespace Musify.Api.Validators.Tracks;
public sealed class RecordListeningProgressRequestValidator : AbstractValidator<RecordListeningProgressRequest>
{
public RecordListeningProgressRequestValidator()
{
RuleFor(x => x.PlayedSeconds)
.Must(seconds => double.IsFinite(seconds) && seconds >= 0)
.WithMessage("'Played Seconds' must be a non-negative number.");
}
}
backend/Tests/Musify.Api.Tests/Endpoints/GenreEndpointsTests.cs
-1
View File
@@ -40,7 +40,6 @@ public sealed class GenreEndpointsTests(ApiTestFixture fixture)
tag.TrackId = track.Id;
database.Users.Add(owner);
database.Tracks.Add(track);
database.UserHasTracks.Add(new UserHasTrack { UserId = owner.Id, TrackId = track.Id });
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
return title;
}
backend/Tests/Musify.Api.Tests/Validators/TrackRequestValidatorTests.cs
+48
View File
@@ -0,0 +1,48 @@
using Musify.Api.DataTransferObjects.Tracks;
using Musify.Api.Validators.Tracks;
using Musify.Domain.ValueObjects;
using Xunit;
namespace Musify.Api.Tests.Validators;
public sealed class TrackRequestValidatorTests
{
[Fact]
public void CreateTrack_ValidRequest_Passes()
{
var request = new CreateTrackRequest("Song", Guid.NewGuid(), Guid.NewGuid(), [Genre.Pop, Genre.Rock]);
Assert.True(new CreateTrackRequestValidator().Validate(request).IsValid);
}
[Fact]
public void CreateTrack_NoTags_Fails()
{
var request = new CreateTrackRequest("Song", Guid.NewGuid(), Guid.NewGuid(), []);
Assert.False(new CreateTrackRequestValidator().Validate(request).IsValid);
}
[Fact]
public void CreateTrack_IncompatibleTags_Fails()
{
var request = new CreateTrackRequest("Song", Guid.NewGuid(), Guid.NewGuid(), [Genre.Classical, Genre.Metal]);
Assert.False(new CreateTrackRequestValidator().Validate(request).IsValid);
}
[Theory]
[InlineData(-1)]
[InlineData(double.NaN)]
[InlineData(double.PositiveInfinity)]
public void RecordListeningProgress_InvalidSeconds_Fails(double seconds)
{
Assert.False(new RecordListeningProgressRequestValidator().Validate(new RecordListeningProgressRequest(seconds)).IsValid);
}
[Fact]
public void RecordListeningProgress_ZeroSeconds_Passes()
{
Assert.True(new RecordListeningProgressRequestValidator().Validate(new RecordListeningProgressRequest(0)).IsValid);
}
}
backend/Tests/Musify.Application.Tests/Albums/AddTrackToAlbumCommandHandlerTests.cs → backend/Tests/Musify.Application.Tests/Albums/AddTracksToAlbumCommandHandlerTests.cs
+12 -11
View File
@@ -7,9 +7,9 @@ using Xunit;
namespace Musify.Application.Tests.Albums;
public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
public sealed class AddTracksToAlbumCommandHandlerTests : HandlerTestBase
{
private AddTrackToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToAlbumCommandHandler>());
private AddTracksToAlbumCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToAlbumCommandHandler>());
[Fact]
public async Task Handle_FirstTrack_AddsItAtNumberOne()
@@ -19,7 +19,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
var track = TestEntities.Track(owner);
await SeedAsync(owner, album, track);
var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
var link = Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
@@ -33,7 +33,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
var track = TestEntities.Track(owner);
await SeedAsync(owner, track);
var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, Guid.NewGuid(), track.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, Guid.NewGuid(), [track.Id]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
@@ -47,7 +47,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
var track = TestEntities.Track(owner);
await SeedAsync(owner, stranger, album, track);
var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(stranger.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(stranger.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
}
@@ -59,7 +59,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
var album = TestEntities.Album(owner.Id);
await SeedAsync(owner, album);
var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, Guid.NewGuid()), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
@@ -73,13 +73,13 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
var foreignTrack = TestEntities.Track(otherOwner);
await SeedAsync(owner, otherOwner, album, foreignTrack);
var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, foreignTrack.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [foreignTrack.Id]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
}
[Fact]
public async Task Handle_AlreadyInAlbum_ReturnsConflict()
public async Task Handle_AlreadyInAlbum_IsSkipped()
{
var owner = TestEntities.User();
var album = TestEntities.Album(owner.Id);
@@ -87,9 +87,10 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
await SeedAsync(owner, album, track, link);
var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, track.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [track.Id]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
Assert.False(result.IsError);
Assert.Single(await Database.AlbumHasTracks.ToListAsync(TestContext.Current.CancellationToken));
}
[Fact]
@@ -102,7 +103,7 @@ public sealed class AddTrackToAlbumCommandHandlerTests : HandlerTestBase
var existingLink = new AlbumHasTrack { AlbumId = album.Id, TrackId = firstTrack.Id, TrackNumber = 3 };
await SeedAsync(owner, album, firstTrack, secondTrack, existingLink);
var result = await CreateHandler().Handle(new AddTrackToAlbumCommand(owner.Id, album.Id, secondTrack.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToAlbumCommand(owner.Id, album.Id, [secondTrack.Id]), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
var newLink = await Database.AlbumHasTracks.SingleAsync(l => l.TrackId == secondTrack.Id, TestContext.Current.CancellationToken);
backend/Tests/Musify.Application.Tests/Genres/GetGenresQueryHandlerTests.cs
+1 -32
View File
@@ -1,6 +1,5 @@
using Musify.Application.Genres;
using Musify.Application.Tests.TestSupport;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
using Xunit;
@@ -26,10 +25,7 @@ public sealed class GetGenresQueryHandlerTests : HandlerTestBase
var rockB = TestEntities.Track(owner, "Rock B", tags: [Genre.Rock, Genre.Indie]);
var jazz = TestEntities.Track(owner, "Jazz", tags: [Genre.Jazz]);
await SeedAsync(
owner, rockA, rockB, jazz,
new UserHasTrack { UserId = owner.Id, TrackId = rockA.Id },
new UserHasTrack { UserId = owner.Id, TrackId = rockB.Id },
new UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
owner, rockA, rockB, jazz);
var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
@@ -38,31 +34,4 @@ public sealed class GetGenresQueryHandlerTests : HandlerTestBase
result.Select(r => (r.Genre, r.TrackCount)));
}
[Fact]
public async Task Handle_TrackInSeveralLibraries_IsCountedOnce()
{
var owner = TestEntities.User();
var other = TestEntities.User(id: 2, name: "other-user");
var track = TestEntities.Track(owner, tags: [Genre.Pop]);
await SeedAsync(
owner, other, track,
new UserHasTrack { UserId = owner.Id, TrackId = track.Id },
new UserHasTrack { UserId = other.Id, TrackId = track.Id });
var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
Assert.Equal(1, Assert.Single(result).TrackCount);
}
[Fact]
public async Task Handle_TrackNotInAnyLibrary_IsIgnored()
{
var owner = TestEntities.User();
var track = TestEntities.Track(owner, tags: [Genre.Metal]);
await SeedAsync(owner, track);
var result = await CreateHandler().Handle(new GetGenresQuery(), TestContext.Current.CancellationToken);
Assert.Empty(result);
}
}
backend/Tests/Musify.Application.Tests/Mixes/GenerateMixesForUserCommandHandlerTests.cs
+8 -12
View File
@@ -1,7 +1,7 @@
using Microsoft.EntityFrameworkCore;
using Musify.Application.Mixes;
using Musify.Application.Tests.TestSupport;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
using Xunit;
namespace Musify.Application.Tests.Mixes;
@@ -30,7 +30,6 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
var track = TestEntities.Track(user);
await SeedAsync(
user, track,
new UserHasTrack { UserId = user.Id, TrackId = track.Id },
TestEntities.ListeningHistory(user.Id, track.Id));
var result = await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
@@ -38,7 +37,7 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
Assert.False(result.IsError);
var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
Assert.Single(mixes);
Assert.Equal("Tu mezcla diaria", mixes[0].Title);
Assert.Equal(MixKind.Daily, mixes[0].Kind);
}
[Fact]
@@ -48,25 +47,23 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
var listenedTrack = TestEntities.Track(user, "Listened Track");
var unheardTrack = TestEntities.Track(user, "Unheard Track");
var staleMix = TestEntities.Mix(user.Id, "Stale Mix");
var staleMix = TestEntities.Mix(user.Id, MixKind.Daily);
var staleItem = TestEntities.MixItem(staleMix.Id, listenedTrack.Id);
await SeedAsync(
user, listenedTrack, unheardTrack, staleMix, staleItem,
new UserHasTrack { UserId = user.Id, TrackId = listenedTrack.Id },
new UserHasTrack { UserId = user.Id, TrackId = unheardTrack.Id },
TestEntities.ListeningHistory(user.Id, listenedTrack.Id));
var result = await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
Assert.DoesNotContain(mixes, mix => mix.Title == "Stale Mix");
Assert.Contains(mixes, mix => mix.Title == "Descubrimiento");
Assert.Contains(mixes, mix => mix.Title == "Tu mezcla diaria");
Assert.DoesNotContain(mixes, mix => mix.Id == staleMix.Id);
Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
Assert.Contains(mixes, mix => mix.Kind == MixKind.Daily);
Assert.Empty(await Database.MixItems.Where(item => item.MixId == staleMix.Id).ToListAsync(TestContext.Current.CancellationToken));
var discoveryMix = mixes.Single(mix => mix.Title == "Descubrimiento");
var discoveryMix = mixes.Single(mix => mix.Kind == MixKind.Discovery);
var discoveryItems = await Database.MixItems
.Where(item => item.MixId == discoveryMix.Id)
.ToListAsync(TestContext.Current.CancellationToken);
@@ -80,12 +77,11 @@ public sealed class GenerateMixesForUserCommandHandlerTests : HandlerTestBase
var skipped = TestEntities.Track(user, "Only skipped");
await SeedAsync(
user, skipped,
new UserHasTrack { UserId = user.Id, TrackId = skipped.Id },
TestEntities.ListeningHistory(user.Id, skipped.Id, playedSeconds: 3, isCounted: false));
await CreateHandler().Handle(new GenerateMixesForUserCommand(user.Id), TestContext.Current.CancellationToken);
var mixes = await Database.Mixes.ToListAsync(TestContext.Current.CancellationToken);
Assert.Contains(mixes, mix => mix.Title == "Descubrimiento");
Assert.Contains(mixes, mix => mix.Kind == MixKind.Discovery);
}
}
backend/Tests/Musify.Application.Tests/Mixes/GetMixByIdQueryHandlerTests.cs
+3 -2
View File
@@ -1,6 +1,7 @@
using ErrorOr;
using Musify.Application.Mixes;
using Musify.Application.Tests.TestSupport;
using Musify.Domain.ValueObjects;
using Xunit;
namespace Musify.Application.Tests.Mixes;
@@ -15,7 +16,7 @@ public sealed class GetMixByIdQueryHandlerTests : HandlerTestBase
var owner = TestEntities.User();
var firstTrack = TestEntities.Track(owner, "First");
var secondTrack = TestEntities.Track(owner, "Second");
var mix = TestEntities.Mix(owner.Id, "Discovery");
var mix = TestEntities.Mix(owner.Id, MixKind.Daily);
var second = TestEntities.MixItem(mix.Id, secondTrack.Id, position: 1);
var first = TestEntities.MixItem(mix.Id, firstTrack.Id, position: 0);
await SeedAsync(owner, firstTrack, secondTrack, mix, second, first);
@@ -23,7 +24,7 @@ public sealed class GetMixByIdQueryHandlerTests : HandlerTestBase
var result = await CreateHandler().Handle(new GetMixByIdQuery(owner.Id, mix.Id), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
Assert.Equal("Discovery", result.Value.Title);
Assert.Equal(MixKind.Daily, result.Value.Kind);
Assert.Equal(["First", "Second"], result.Value.Items.Select(item => item.Title));
}
backend/Tests/Musify.Application.Tests/Mixes/GetMixesByUserIdQueryHandlerTests.cs
+5 -4
View File
@@ -1,5 +1,6 @@
using Musify.Application.Mixes;
using Musify.Application.Tests.TestSupport;
using Musify.Domain.ValueObjects;
using Xunit;
namespace Musify.Application.Tests.Mixes;
@@ -13,13 +14,13 @@ public sealed class GetMixesByUserIdQueryHandlerTests : HandlerTestBase
{
var owner = TestEntities.User(1, "owner");
var other = TestEntities.User(2, "other");
var second = TestEntities.Mix(owner.Id, "Second", position: 1);
var first = TestEntities.Mix(owner.Id, "First", position: 0);
var theirs = TestEntities.Mix(other.Id, "Theirs");
var second = TestEntities.Mix(owner.Id, MixKind.Daily, position: 1);
var first = TestEntities.Mix(owner.Id, MixKind.Discovery, position: 0);
var theirs = TestEntities.Mix(other.Id);
await SeedAsync(owner, other, second, first, theirs);
var result = await CreateHandler().Handle(new GetMixesByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
Assert.Equal(["First", "Second"], result.Select(mix => mix.Title));
Assert.Equal([MixKind.Discovery, MixKind.Daily], result.Select(mix => mix.Kind));
}
[Fact]
backend/Tests/Musify.Application.Tests/PlayLists/AddTrackToPlayListCommandHandlerTests.cs → backend/Tests/Musify.Application.Tests/PlayLists/AddTracksToPlayListCommandHandlerTests.cs
+33 -10
View File
@@ -7,9 +7,9 @@ using Xunit;
namespace Musify.Application.Tests.PlayLists;
public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
public sealed class AddTracksToPlayListCommandHandlerTests : HandlerTestBase
{
private AddTrackToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTrackToPlayListCommandHandler>());
private AddTracksToPlayListCommandHandler CreateHandler() => new(Database, NoOpLogger<AddTracksToPlayListCommandHandler>());
[Fact]
public async Task Handle_FirstTrack_AddsItAtPositionZero()
@@ -19,7 +19,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
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 AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
var link = Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
@@ -37,7 +37,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
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 AddTracksToPlayListCommand(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);
@@ -47,7 +47,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
[Fact]
public async Task Handle_PlayListMissing_ReturnsNotFound()
{
var result = await CreateHandler().Handle(new AddTrackToPlayListCommand(1, Guid.NewGuid(), Guid.NewGuid()), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new AddTracksToPlayListCommand(1, Guid.NewGuid(), [Guid.NewGuid()]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
@@ -60,7 +60,7 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
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 AddTracksToPlayListCommand(stranger.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Forbidden, result.FirstError.Type);
}
@@ -72,22 +72,23 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
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 AddTracksToPlayListCommand(owner.Id, playList.Id, [Guid.NewGuid()]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
[Fact]
public async Task Handle_TrackAlreadyInPlayList_ReturnsConflict()
public async Task Handle_TrackAlreadyInPlayList_IsSkipped()
{
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 AddTracksToPlayListCommand(owner.Id, playList.Id, [track.Id]), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
Assert.False(result.IsError);
Assert.Single(await Database.PlayListHasTracks.ToListAsync(TestContext.Current.CancellationToken));
}
[Fact]
@@ -103,4 +104,26 @@ public sealed class AddTrackToPlayListCommandHandlerTests : HandlerTestBase
Assert.Equal("Test.Duplicate", result.FirstError.Code);
}
[Fact]
public async Task Handle_SeveralTracks_AppendsThemInOrderSkippingExistingOnes()
{
var owner = TestEntities.User();
var playList = TestEntities.PlayList(owner.Id);
var existing = TestEntities.Track(owner, "Existing");
var first = TestEntities.Track(owner, "First");
var second = TestEntities.Track(owner, "Second");
await SeedAsync(
owner, playList, existing, first, second,
new PlayListHasTrack { PlayListId = playList.Id, TrackId = existing.Id, Position = 0 });
var result = await CreateHandler().Handle(
new AddTracksToPlayListCommand(owner.Id, playList.Id, [first.Id, existing.Id, second.Id, first.Id]),
TestContext.Current.CancellationToken);
Assert.False(result.IsError);
var links = await Database.PlayListHasTracks.OrderBy(link => link.Position).ToListAsync(TestContext.Current.CancellationToken);
Assert.Equal([existing.Id, first.Id, second.Id], links.Select(link => link.TrackId));
Assert.Equal([0, 1, 2], links.Select(link => link.Position));
}
}
backend/Tests/Musify.Application.Tests/Services/TrackStreamIssuerTests.cs
+17 -52
View File
@@ -1,4 +1,3 @@
using Microsoft.EntityFrameworkCore;
using Musify.Application.Configuration;
using Musify.Application.Contracts;
using Musify.Application.Services;
@@ -8,90 +7,56 @@ using Xunit;
namespace Musify.Application.Tests.Services;
public sealed class TrackStreamIssuerTests : HandlerTestBase
public sealed class TrackStreamIssuerTests
{
private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
public TrackStreamIssuerTests() =>
ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("signed-token", 120));
private TrackStreamIssuer CreateIssuer(PlaybackConfiguration? playback = null) => new(
Database,
ticketService,
TestConfigurations.Track(),
TestConfigurations.StreamGateway("https://stream.musify.test/"),
playback ?? TestConfigurations.Playback());
[Fact]
public async Task IssueAsync_BuildsManifestUrlAndRecordsListeningHistory()
public void Issue_BuildsManifestUrlAndCarriesTheListenId()
{
ticketService.IssueTicket(7, Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("signed-token", 120));
var owner = TestEntities.User(7);
var track = TestEntities.Track(owner);
await SeedAsync(owner, track);
var listenId = Guid.NewGuid();
var response = await CreateIssuer().IssueAsync(track.Id, "folder-42", userId: 7, TestContext.Current.CancellationToken);
var response = CreateIssuer().Issue("folder-42", userId: 7, listenId);
Assert.Equal("signed-token", response.Ticket);
Assert.Equal(120, response.ExpiresInSeconds);
Assert.Equal(
"https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a",
response.ManifestUrl);
var history = Assert.Single(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
Assert.Equal(7, history.UserId);
Assert.Equal(track.Id, history.TrackId);
Assert.Equal(listenId, response.ListenId);
Assert.Equal("https://stream.musify.test/media/Tracks/ProcessedAudios/folder-42/audio.m4a", response.ManifestUrl);
}
[Fact]
public async Task IssueAsync_PassesTheProcessedAudioKeyPrefixToTheTicketService()
public void Issue_PassesTheProcessedAudioKeyPrefixToTheTicketService()
{
ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
var owner = TestEntities.User(1);
var track = TestEntities.Track(owner);
await SeedAsync(owner, track);
await CreateIssuer().IssueAsync(track.Id, "folder-42", userId: 1, TestContext.Current.CancellationToken);
CreateIssuer().Issue("folder-42", userId: 1, listenId: null);
ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
}
[Fact]
public async Task IssueAsync_AnonymousUser_SkipsListeningHistoryAndNeverThrows()
public void Issue_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
{
ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
var owner = TestEntities.User(1);
var track = TestEntities.Track(owner);
await SeedAsync(owner, track);
var response = await CreateIssuer(TestConfigurations.Playback(allowAnonymousListening: true))
.IssueAsync(track.Id, "folder-42", userId: null, TestContext.Current.CancellationToken);
Assert.Equal("token", response.Ticket);
Assert.Empty(await Database.ListeningHistories.ToListAsync(TestContext.Current.CancellationToken));
}
[Fact]
public async Task IssueAsync_AnonymousUserWithFragmentConfigured_PassesTheByteCapToTheTicketService()
{
ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
var owner = TestEntities.User(1);
var track = TestEntities.Track(owner);
await SeedAsync(owner, track);
var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
await CreateIssuer(playback).IssueAsync(track.Id, "folder-42", userId: null, TestContext.Current.CancellationToken);
CreateIssuer(playback).Issue("folder-42", userId: null, listenId: null);
ticketService.Received(1).IssueTicket(null, "Tracks/ProcessedAudios/folder-42/", 30L * playback.EstimatedAudioBytesPerSecond);
}
[Fact]
public async Task IssueAsync_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
public void Issue_AuthenticatedUser_IgnoresTheAnonymousFragmentCap()
{
ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("token", 60));
var owner = TestEntities.User(1);
var track = TestEntities.Track(owner);
await SeedAsync(owner, track);
var playback = TestConfigurations.Playback(allowAnonymousListening: true, anonymousFragmentSeconds: 30);
await CreateIssuer(playback).IssueAsync(track.Id, "folder-42", userId: 1, TestContext.Current.CancellationToken);
CreateIssuer(playback).Issue("folder-42", userId: 1, listenId: null);
ticketService.Received(1).IssueTicket(1, "Tracks/ProcessedAudios/folder-42/", null);
}
backend/Tests/Musify.Application.Tests/TestSupport/TestDatabase.cs
-2
View File
@@ -143,8 +143,6 @@ public sealed class TestDatabase : DbContext, IDatabase
public DbSet<Track> Tracks => Set<Track>();
public DbSet<UserHasTrack> UserHasTracks => Set<UserHasTrack>();
public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
public DbSet<Mix> Mixes => Set<Mix>();
backend/Tests/Musify.Application.Tests/TestSupport/TestEntities.cs
+2 -4
View File
@@ -154,14 +154,12 @@ public static class TestEntities
public static Mix Mix(
long userId,
string title = "Test Mix",
string? subtitle = null,
MixKind kind = MixKind.Discovery,
int position = 0) =>
new()
{
UserId = userId,
Title = title,
Subtitle = subtitle,
Kind = kind,
Position = position
};
backend/Tests/Musify.Application.Tests/Tracks/CreateTrackCommandHandlerTests.cs
-28
View File
@@ -89,34 +89,6 @@ public sealed class CreateTrackCommandHandlerTests : HandlerTestBase
Assert.Equal(isExplicit, stored.IsExplicit);
}
[Fact]
public async Task Handle_NoTags_ReturnsValidationError()
{
var user = TestEntities.User();
var (picture, audio) = SeedIntents(user.Id);
await SeedAsync(user, picture, audio);
var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, []);
var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Validation, result.FirstError.Type);
}
[Fact]
public async Task Handle_IncompatibleTags_ReturnsValidationError()
{
var user = TestEntities.User();
var (picture, audio) = SeedIntents(user.Id);
await SeedAsync(user, picture, audio);
var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id, [Genre.Classical, Genre.Metal]);
var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Validation, result.FirstError.Type);
}
[Fact]
public async Task Handle_UserMissing_ReturnsNotFound()
{
backend/Tests/Musify.Application.Tests/Tracks/GetTracksByUserIdQueryHandlerTests.cs
+1 -4
View File
@@ -1,6 +1,5 @@
using Musify.Application.Tests.TestSupport;
using Musify.Application.Tracks;
using Musify.Domain.Entities;
using Xunit;
namespace Musify.Application.Tests.Tracks;
@@ -17,9 +16,7 @@ public sealed class GetTracksByUserIdQueryHandlerTests : HandlerTestBase
var mine = TestEntities.Track(owner, "Mine");
var theirs = TestEntities.Track(other, "Theirs");
await SeedAsync(
owner, other, mine, theirs,
new UserHasTrack { UserId = owner.Id, TrackId = mine.Id },
new UserHasTrack { UserId = other.Id, TrackId = theirs.Id });
owner, other, mine, theirs);
var result = await CreateHandler().Handle(new GetTracksByUserIdQuery(owner.Id, Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
backend/Tests/Musify.Application.Tests/Tracks/GetTracksQueryHandlerTests.cs
+3 -9
View File
@@ -16,9 +16,7 @@ public sealed class GetTracksQueryHandlerTests : HandlerTestBase
var trackA = TestEntities.Track(owner, "Alpha");
var trackB = TestEntities.Track(owner, "Beta");
await SeedAsync(
owner, trackA, trackB,
new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = trackA.Id },
new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = trackB.Id });
owner, trackA, trackB);
var result = await CreateHandler().Handle(new GetTracksQuery(Name: null, PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
Assert.Equal(2, result.TotalItemCount);
@@ -32,9 +30,7 @@ public sealed class GetTracksQueryHandlerTests : HandlerTestBase
var match = TestEntities.Track(owner, "Bohemian Rhapsody");
var other = TestEntities.Track(owner, "Imagine");
await SeedAsync(
owner, match, other,
new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = match.Id },
new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = other.Id });
owner, match, other);
var result = await CreateHandler().Handle(new GetTracksQuery(Name: "rhapsody", PageNumber: 1, PageSize: 10), TestContext.Current.CancellationToken);
var item = Assert.Single(result.Items);
@@ -48,9 +44,7 @@ public sealed class GetTracksQueryHandlerTests : HandlerTestBase
var rock = TestEntities.Track(owner, "Loud", tags: [Genre.Rock, Genre.Indie]);
var jazz = TestEntities.Track(owner, "Smooth", tags: [Genre.Jazz]);
await SeedAsync(
owner, rock, jazz,
new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = rock.Id },
new Musify.Domain.Entities.UserHasTrack { UserId = owner.Id, TrackId = jazz.Id });
owner, rock, jazz);
var result = await CreateHandler().Handle(new GetTracksQuery(null, 1, 10, Genre.Indie), TestContext.Current.CancellationToken);
var item = Assert.Single(result.Items);
backend/Tests/Musify.Application.Tests/Tracks/RecordListeningProgressCommandHandlerTests.cs
-13
View File
@@ -110,17 +110,4 @@ public sealed class RecordListeningProgressCommandHandlerTests : HandlerTestBase
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
[Theory]
[InlineData(-1)]
[InlineData(double.NaN)]
[InlineData(double.PositiveInfinity)]
public async Task Handle_InvalidSeconds_ReturnsValidationError(double seconds)
{
var (user, listen) = await SeedListenAsync(200, DateTime.UtcNow.AddSeconds(-60));
var result = await CreateHandler().Handle(
new RecordListeningProgressCommand(user.Id, listen.Id, seconds), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Validation, result.FirstError.Type);
}
}
backend/Tests/Musify.Application.Tests/Tracks/GetTrackStreamQueryHandlerTests.cs → backend/Tests/Musify.Application.Tests/Tracks/StartListeningCommandHandlerTests.cs
+8 -9
View File
@@ -10,22 +10,21 @@ using Xunit;
namespace Musify.Application.Tests.Tracks;
public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
public sealed class StartListeningCommandHandlerTests : HandlerTestBase
{
private readonly IStreamTicketService ticketService = Substitute.For<IStreamTicketService>();
private GetTrackStreamQueryHandler CreateHandler(PlaybackConfiguration? playback = null)
private StartListeningCommandHandler CreateHandler(PlaybackConfiguration? playback = null)
{
ticketService.IssueTicket(Arg.Any<long?>(), Arg.Any<string>(), Arg.Any<long?>()).Returns(new StreamTicket("ticket-token", 60));
var issuer = new TrackStreamIssuer(
Database,
ticketService,
TestConfigurations.Track(),
TestConfigurations.StreamGateway("https://stream.musify.test"),
playback ?? TestConfigurations.Playback());
return new GetTrackStreamQueryHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<GetTrackStreamQueryHandler>());
return new StartListeningCommandHandler(Database, issuer, playback ?? TestConfigurations.Playback(), NoOpLogger<StartListeningCommandHandler>());
}
[Fact]
@@ -35,7 +34,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
var track = TestEntities.Track(owner);
await SeedAsync(owner, track);
var result = await CreateHandler().Handle(new GetTrackStreamQuery(track.Id, owner.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
Assert.Equal("ticket-token", result.Value.Ticket);
@@ -53,7 +52,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
[Fact]
public async Task Handle_TrackMissing_ReturnsNotFound()
{
var result = await CreateHandler().Handle(new GetTrackStreamQuery(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new StartListeningCommand(Guid.NewGuid(), 1), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
@@ -65,7 +64,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
var track = TestEntities.Track(owner, audio: TestEntities.PendingAudio());
await SeedAsync(owner, track);
var result = await CreateHandler().Handle(new GetTrackStreamQuery(track.Id, owner.Id), TestContext.Current.CancellationToken);
var result = await CreateHandler().Handle(new StartListeningCommand(track.Id, owner.Id), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
}
@@ -79,7 +78,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: false));
var result = await handler.Handle(new GetTrackStreamQuery(track.Id, UserId: null), TestContext.Current.CancellationToken);
var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.Unauthorized, result.FirstError.Type);
}
@@ -93,7 +92,7 @@ public sealed class GetTrackStreamQueryHandlerTests : HandlerTestBase
var handler = CreateHandler(TestConfigurations.Playback(allowAnonymousListening: true));
var result = await handler.Handle(new GetTrackStreamQuery(track.Id, UserId: null), TestContext.Current.CancellationToken);
var result = await handler.Handle(new StartListeningCommand(track.Id, UserId: null), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
Assert.Equal("ticket-token", result.Value.Ticket);