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

Update packages

Browse Source
This commit is contained in:
Admin
2026-09-20 16:00:57 +02:00
parent c14db5a711
commit 3f5e01f910
51 changed files with 2508 additions and 389 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/Tests/Musify.Api.Tests/Endpoints/UserEndpointsTests.cs
+62
View File
@@ -1,8 +1,15 @@
using System.Net;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Musify.Api.DataTransferObjects.Users;
using Musify.Api.Tests.TestSupport;
using Musify.Application.Tracks.Responses;
using Musify.Application.Users.Responses;
using Musify.Domain.Entities;
using Musify.Infrastructure.Persistence;
using Xunit;
namespace Musify.Api.Tests.Endpoints
@@ -10,6 +17,33 @@ namespace Musify.Api.Tests.Endpoints
[Collection(ApiCollection.Name)]
public sealed class UserEndpointsTests(ApiTestFixture fixture)
{
private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
{
Converters = { new JsonStringEnumConverter() }
};
private async Task SeedListenAsync(long userId, string trackTitle, DateTime listenedAt)
{
using var scope = fixture.Services.CreateScope();
var database = scope.ServiceProvider.GetRequiredService<Database>();
var owner = await database.Users.SingleAsync(u => u.Id == userId);
var track = new Track
{
Title = trackTitle,
NormalizedTitle = trackTitle.ToUpperInvariant(),
OwnerUserId = owner.Id,
Owner = owner
};
database.Tracks.Add(track);
database.ListeningHistories.Add(new ListeningHistory
{
UserId = userId,
TrackId = track.Id,
ListenedAt = listenedAt
});
await database.SaveChangesAsync(TestContext.Current.CancellationToken);
}
[Fact]
public async Task PostUsers_NewUser_ReturnsCreatedWithLocationHeader()
{
@@ -70,5 +104,33 @@ namespace Musify.Api.Tests.Endpoints
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
[Fact]
public async Task GetLastTrackListenedByUserId_HasHistory_ReturnsMostRecentTrack()
{
var client = fixture.CreateAnonymousClient();
var userId = Random.Shared.NextInt64(1, long.MaxValue);
await client.PostAsJsonAsync("/users", new CreateUserRequest(userId, $"user-{userId}", null, null), TestContext.Current.CancellationToken);
await SeedListenAsync(userId, "Older listen", DateTime.UtcNow.AddMinutes(-10));
await SeedListenAsync(userId, "Newer listen", DateTime.UtcNow);
var response = await client.GetAsync($"/users/{userId}/last-listened-track", TestContext.Current.CancellationToken);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var body = await response.Content.ReadFromJsonAsync<TrackApplicationResponse>(JsonOptions, TestContext.Current.CancellationToken);
Assert.Equal("Newer listen", body?.Title);
}
[Fact]
public async Task GetLastTrackListenedByUserId_NoHistory_ReturnsNotFound()
{
var client = fixture.CreateAnonymousClient();
var userId = Random.Shared.NextInt64(1, long.MaxValue);
await client.PostAsJsonAsync("/users", new CreateUserRequest(userId, $"user-{userId}", null, null), TestContext.Current.CancellationToken);
var response = await client.GetAsync($"/users/{userId}/last-listened-track", TestContext.Current.CancellationToken);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
}
}
backend/Tests/Musify.Api.Tests/TestSupport/ApiTestFixture.cs
-1
View File
@@ -78,7 +78,6 @@ namespace Musify.Api.Tests.TestSupport
["InfrastructureStorage:UseHttp"] = "true",
["ApplicationStorage:Bucket"] = "musify-api-test",
["StreamGateway:PublicBaseUrl"] = "http://stream.musify.test",
["PlayList:SeedPresetPictures"] = "false",
});
});
backend/Tests/Musify.Application.Tests/PlayLists/CreatePlayListCommandHandlerTests.cs
+2 -2
View File
@@ -23,7 +23,7 @@ namespace Musify.Application.Tests.PlayLists
TestConfigurations.UploadIntent());
[Fact]
public async Task Handle_NoPictureIntent_CreatesPlayListWithPresetPictures()
public async Task Handle_NoPictureIntent_CreatesPlayListWithoutPictures()
{
var user = TestEntities.User();
await SeedAsync(user);
@@ -34,7 +34,7 @@ namespace Musify.Application.Tests.PlayLists
Assert.False(result.IsError);
Assert.Equal("My Playlist", result.Value.Name);
Assert.Equal("PresetSmallPicture.webp", result.Value.SmallImageKeyName);
Assert.Null(result.Value.SmallImageKeyName);
await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreatePlayListResourcesEvent>(), Arg.Any<CancellationToken>());
}
backend/Tests/Musify.Application.Tests/PlayLists/GetPlayListCoverQueryHandlerTests.cs
+13
View File
@@ -34,5 +34,18 @@ namespace Musify.Application.Tests.PlayLists
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
[Fact]
public async Task Handle_PlayListWithoutPictures_ReturnsNotFound()
{
var owner = TestEntities.User();
var playList = TestEntities.PlayList(owner.Id);
playList.Pictures = null;
await SeedAsync(owner, playList);
var result = await CreateHandler().Handle(new GetPlayListCoverQuery(playList.Id, "small"), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
}
}
backend/Tests/Musify.Application.Tests/TestSupport/TestDatabase.cs
+8 -2
View File
@@ -45,8 +45,14 @@ namespace Musify.Application.Tests.TestSupport
.HasForeignKey(track => track.OwnerUserId)
.OnDelete(DeleteBehavior.Restrict);
modelBuilder.Entity<PlayList>().OwnsOne(playList => playList.Pictures);
modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired();
modelBuilder.Entity<PlayList>().OwnsOne(playList => playList.Pictures, pictures =>
{
pictures.Property(p => p.OriginalName).IsRequired(false);
pictures.Property(p => p.SmallName).IsRequired(false);
pictures.Property(p => p.MediumName).IsRequired(false);
pictures.Property(p => p.LargeName).IsRequired(false);
});
modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired(false);
modelBuilder.Entity<Album>().OwnsOne(album => album.Pictures);
modelBuilder.Entity<Album>().Navigation(album => album.Pictures).IsRequired(false);
backend/Tests/Musify.Application.Tests/Tracks/GetLastTrackListenedByUserIdQueryHandlerTests.cs
+40
View File
@@ -0,0 +1,40 @@
using ErrorOr;
using Musify.Application.Tests.TestSupport;
using Musify.Application.Tracks;
using Xunit;
namespace Musify.Application.Tests.Tracks
{
public sealed class GetLastTrackListenedByUserIdQueryHandlerTests : HandlerTestBase
{
private GetLastTrackListenedByUserIdQueryHandler CreateHandler() => new(Database);
[Fact]
public async Task Handle_MultipleListens_ReturnsMostRecentlyListenedTrack()
{
var owner = TestEntities.User();
var older = TestEntities.Track(owner, "Older listen");
var newer = TestEntities.Track(owner, "Newer listen");
await SeedAsync(
owner, older, newer,
TestEntities.ListeningHistory(owner.Id, older.Id, DateTime.UtcNow.AddMinutes(-10)),
TestEntities.ListeningHistory(owner.Id, newer.Id, DateTime.UtcNow));
var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
Assert.False(result.IsError);
Assert.Equal("Newer listen", result.Value.Title);
}
[Fact]
public async Task Handle_NoHistory_ReturnsNotFound()
{
var owner = TestEntities.User();
await SeedAsync(owner);
var result = await CreateHandler().Handle(new GetLastTrackListenedByUserIdQuery(owner.Id), TestContext.Current.CancellationToken);
Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
}
}
}
backend/Tests/Musify.Infrastructure.Tests/Services/PlayListPresetSeederTests.cs
-103
View File
@@ -1,103 +0,0 @@
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging.Abstractions;
using Musify.Application.Configuration;
using Musify.Application.Contracts;
using Musify.Infrastructure.Configuration;
using Musify.Infrastructure.Services;
using Musify.Infrastructure.Tests.TestSupport;
using Xunit;
namespace Musify.Infrastructure.Tests.Services
{
[Collection(InfrastructureCollection.Name)]
public sealed class PlayListPresetSeederTests(InfrastructureTestFixture fixture)
{
private static PlayListConfiguration NewConfiguration(bool overwritePresetPictures) => new()
{
Routes = new PlayListRoutes { ParentFolders = $"PlayLists-{Guid.NewGuid():N}" },
SeedPresetPictures = true,
OverwritePresetPictures = overwritePresetPictures
};
private (PlayListPresetSeeder Seeder, IStorageService Storage) Build(PlayListConfiguration configuration)
{
var services = new ServiceCollection();
services.AddSingleton(configuration);
services.AddSingleton(new ApplicationStorageConfiguration { Bucket = InfrastructureTestFixture.S3Bucket });
services.AddSingleton<IStorageService>(_ => new StorageService(
fixture.CreateDatabase(),
fixture.CreateS3Client(),
NullLogger<StorageService>.Instance,
new InfrastructureStorageConfiguration
{
Address = fixture.S3ServiceUrl,
AccessKey = InfrastructureTestFixture.S3AccessKey,
SecretAccessKey = InfrastructureTestFixture.S3SecretKey,
ForcePathStyle = true,
UseHttp = true,
}));
services.AddSingleton<IPictureService>(new PictureService(NullLogger<PictureService>.Instance));
var provider = services.BuildServiceProvider();
var seeder = new PlayListPresetSeeder(provider.GetRequiredService<IServiceScopeFactory>(), NullLogger<PlayListPresetSeeder>.Instance);
return (seeder, provider.GetRequiredService<IStorageService>());
}
private static async Task RunToCompletionAsync(PlayListPresetSeeder seeder)
{
await seeder.StartAsync(TestContext.Current.CancellationToken);
await (seeder.ExecuteTask ?? Task.CompletedTask);
}
[Fact]
public async Task ExecuteAsync_SeedsAllFourPresetPictures()
{
var configuration = NewConfiguration(overwritePresetPictures: false);
var (seeder, storage) = Build(configuration);
await RunToCompletionAsync(seeder);
var routes = configuration.Routes;
foreach (var key in new[]
{
routes.BuildOriginalPicturePath(routes.PresetOriginalPicture),
routes.PresetSmallPicturePath,
routes.PresetMediumPicturePath,
routes.PresetLargePicturePath
})
{
var metadata = await storage.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, TestContext.Current.CancellationToken);
Assert.True(metadata is not null, $"expected {key} to have been seeded");
}
}
[Fact]
public async Task ExecuteAsync_RunTwiceWithoutOverwrite_StaysIdempotent()
{
var configuration = NewConfiguration(overwritePresetPictures: false);
var (firstSeeder, storage) = Build(configuration);
await RunToCompletionAsync(firstSeeder);
var (secondSeeder, _) = Build(configuration);
await RunToCompletionAsync(secondSeeder);
var metadata = await storage.HeadObjectAsync(
InfrastructureTestFixture.S3Bucket, configuration.Routes.PresetSmallPicturePath, TestContext.Current.CancellationToken);
Assert.NotNull(metadata);
}
[Fact]
public async Task ExecuteAsync_SeedPresetPicturesDisabled_UploadsNothing()
{
var configuration = NewConfiguration(overwritePresetPictures: false);
configuration.SeedPresetPictures = false;
var (seeder, storage) = Build(configuration);
await RunToCompletionAsync(seeder);
var metadata = await storage.HeadObjectAsync(
InfrastructureTestFixture.S3Bucket, configuration.Routes.PresetSmallPicturePath, TestContext.Current.CancellationToken);
Assert.Null(metadata);
}
}
}