Add Infrastructure/Api/StreamingGateway test projects
Second pass on backend/Tests/, covering what Domain+Application (the first
pass) deliberately left out — the parts that talk to real infrastructure:
Musify.Infrastructure.Tests Database/migrations, StorageService,
StreamTicketService, AuditableEntityInterceptor,
PictureService, SingleFlightCache,
PlayListPresetSeeder.
Musify.Api.Tests Real HTTP endpoints via WebApplicationFactory
(routing, auth, ValidationFilter, ErrorOr->HTTP
mapping), plus isolated unit tests for
ErrorOrHttpExtensions, CurrentUser and the
FluentValidation validators.
Musify.StreamingGateway.Tests TicketValidator (RS256) and
TicketValidationMiddleware (path traversal,
prefix boundary, ticket extraction).
Musify.Worker gets no test project: its Program.cs is pure DI/host wiring
(Hangfire, MassTransit, jobs); the logic it runs lives in Musify.Infrastructure,
already covered there.
Per the user's direction, the parts that touch real infrastructure use
Testcontainers instead of fakes: a real Postgres (Testcontainers.PostgreSql)
for Infrastructure.Tests and Api.Tests, and — matching deploy/compose.yml
exactly (chrislusf/seaweedfs:latest, same startup command), not MinIO — a
real SeaweedFS container for StorageService. Api.Tests boots the actual
Musify.Api host against that Postgres (real routing/auth/validation) but
substitutes the services that talk over the network (storage, YouTube, the
message bus, stream-ticket signing) with NSubstitute fakes, and swaps the
JwtBearer scheme for a test-only header-based one (FakeAuthenticationHandler)
so tests don't need a reachable Zitadel. Application.Tests' approach — a real
DbContext (SQLite in-memory) rather than mocking IDatabase, since it exposes
DbSet<T> directly and handlers compose real LINQ queries against it — carries
over into Infrastructure.Tests/Api.Tests via real Postgres instead.
Testing against the real backend (not a fake) found two genuine production
bugs, both fixed here:
- StorageService.RemoveFolderAsync threw NullReferenceException against
SeaweedFS: its DeleteObjects response omits the <Error> list entirely when
nothing failed, which the AWS SDK deserializes as null rather than an empty
list (real AWS S3 always returns one). Now treats null as no errors.
- AuditableEntityInterceptor never bumped UpdatedAt on a normal update (load,
mutate a property, SaveChanges) — only on insert. SavingChanges(Async) fires
before EF's own automatic change detection for that save, so an entity
modified through a plain property setter still reported EntityState.Unchanged
inside the interceptor. Now calls ChangeTracker.DetectChanges() explicitly
first, which is the documented fix for exactly this interceptor pattern.
Also required to make the Api host testable: Program.cs now ends with `public
partial class Program;` (WebApplicationFactory<Program> needs the top-level-
statements Program class to be public — no behavior change), and
Directory.Packages.props gains Microsoft.AspNetCore.Mvc.Testing, Testcontainers
and Testcontainers.PostgreSql.
249 tests total across all five projects, all green: `dotnet test
backend/Musify.slnx` (needs Docker running for Infrastructure.Tests and
Api.Tests).
This commit is contained in:
@@ -0,0 +1,34 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<IsPackable>false</IsPackable>
|
||||
<IsTestProject>true</IsTestProject>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<!-- Testcontainers.PostgreSql pulls an older EFCore.Relational transitively;
|
||||
pin it explicitly so it doesn't win over the 10.0.8 the rest of the
|
||||
solution (and Musify.Infrastructure itself) is built against. -->
|
||||
<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" />
|
||||
<PackageReference Include="NSubstitute" />
|
||||
<PackageReference Include="Testcontainers" />
|
||||
<PackageReference Include="Testcontainers.PostgreSql" />
|
||||
<PackageReference Include="xunit" />
|
||||
<PackageReference Include="xunit.runner.visualstudio">
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
</PackageReference>
|
||||
<PackageReference Include="coverlet.collector">
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
</PackageReference>
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\..\Core\Musify.Domain\Musify.Domain.csproj" />
|
||||
<ProjectReference Include="..\..\Core\Musify.Application\Musify.Application.csproj" />
|
||||
<ProjectReference Include="..\..\Core\Musify.Infrastructure\Musify.Infrastructure.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Musify.Domain.Entities;
|
||||
using Musify.Infrastructure.Tests.TestSupport;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Persistence;
|
||||
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class AuditableEntityInterceptorTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
[Fact]
|
||||
public async Task SavingChanges_NewEntity_SetsCreatedAtAndUpdatedAtToNow()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
var before = DateTime.UtcNow;
|
||||
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = "audit-user", NormalizedName = "AUDIT-USER" };
|
||||
await database.Users.AddAsync(user);
|
||||
await database.SaveChangesAsync(CancellationToken.None);
|
||||
|
||||
var after = DateTime.UtcNow;
|
||||
|
||||
Assert.InRange(user.CreatedAt, before, after);
|
||||
Assert.InRange(user.UpdatedAt, before, after);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SavingChanges_ModifiedEntity_BumpsUpdatedAtButKeepsCreatedAt()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = "audit-user-2", NormalizedName = "AUDIT-USER-2" };
|
||||
await database.Users.AddAsync(user);
|
||||
await database.SaveChangesAsync(CancellationToken.None);
|
||||
var originalCreatedAt = user.CreatedAt;
|
||||
|
||||
await Task.Delay(TimeSpan.FromMilliseconds(50));
|
||||
|
||||
user.Name = "audit-user-2-renamed";
|
||||
await database.SaveChangesAsync(CancellationToken.None);
|
||||
|
||||
Assert.Equal(originalCreatedAt, user.CreatedAt);
|
||||
Assert.True(user.UpdatedAt > originalCreatedAt,
|
||||
$"original-created-at={originalCreatedAt:O}, final-updated-at={user.UpdatedAt:O}");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Musify.Domain.Entities;
|
||||
using Musify.Domain.ValueObjects;
|
||||
using Musify.Infrastructure.Tests.TestSupport;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Persistence;
|
||||
|
||||
[Collection(InfrastructureCollection.Name)]
|
||||
public sealed class DatabaseTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
[Fact]
|
||||
public async Task SaveChangesAsync_LocalTrackWithOwnedTypes_RoundTripsThroughPostgres()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = "roundtrip-user", NormalizedName = "ROUNDTRIP-USER" };
|
||||
await database.Users.AddAsync(user);
|
||||
|
||||
var track = new LocalTrack
|
||||
{
|
||||
Title = "Round Trip Track",
|
||||
NormalizedTitle = "ROUND TRIP TRACK",
|
||||
DurationSeconds = 123.4,
|
||||
OwnerUserId = user.Id,
|
||||
Owner = user,
|
||||
Pictures = new TrackPictures { OriginalName = "cover.webp", ProcessingStatus = ProcessingStatus.Pending },
|
||||
Audio = new TrackAudio { OriginalName = "song.mp3", TranscodeStatus = ProcessingStatus.Pending }
|
||||
};
|
||||
await database.LocalTracks.AddAsync(track);
|
||||
await database.SaveChangesAsync(CancellationToken.None);
|
||||
|
||||
await using var reloaded = fixture.CreateDatabase();
|
||||
var stored = await reloaded.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id);
|
||||
|
||||
Assert.IsType<LocalTrack>(stored);
|
||||
Assert.Equal("Round Trip Track", stored.Title);
|
||||
Assert.Equal("cover.webp", stored.Pictures.OriginalName);
|
||||
Assert.Equal("song.mp3", stored.Audio.OriginalName);
|
||||
Assert.Equal(user.Id, ((LocalTrack)stored).OwnerUserId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ExternalTracks_SourceAndExternalIdUniqueIndex_RejectsDuplicates()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var videoId = $"dup-{Guid.NewGuid():N}";
|
||||
await database.ExternalTracks.AddAsync(BuildExternalTrack(videoId));
|
||||
await database.SaveChangesAsync(CancellationToken.None);
|
||||
|
||||
await using var second = fixture.CreateDatabase();
|
||||
await second.ExternalTracks.AddAsync(BuildExternalTrack(videoId));
|
||||
|
||||
await Assert.ThrowsAsync<DbUpdateException>(() => second.SaveChangesAsync(CancellationToken.None));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AlbumHasTracks_DeletingAlbum_CascadesToTheLinkRows()
|
||||
{
|
||||
await using var database = fixture.CreateDatabase();
|
||||
|
||||
var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = "cascade-user", NormalizedName = "CASCADE-USER" };
|
||||
var album = new UserAlbum { Title = "Cascade Album", NormalizedTitle = "CASCADE ALBUM", OwnerUserId = user.Id };
|
||||
var track = BuildExternalTrack($"cascade-{Guid.NewGuid():N}");
|
||||
var link = new AlbumHasTrack { AlbumId = album.Id, TrackId = track.Id, TrackNumber = 1 };
|
||||
|
||||
await database.AddRangeAsync(user, album, track, link);
|
||||
await database.SaveChangesAsync(CancellationToken.None);
|
||||
|
||||
await using var deleter = fixture.CreateDatabase();
|
||||
var albumToDelete = await deleter.UserAlbums.SingleAsync(a => a.Id == album.Id);
|
||||
deleter.UserAlbums.Remove(albumToDelete);
|
||||
await deleter.SaveChangesAsync(CancellationToken.None);
|
||||
|
||||
await using var verifier = fixture.CreateDatabase();
|
||||
Assert.False(await verifier.AlbumHasTracks.AnyAsync(l => l.AlbumId == album.Id));
|
||||
Assert.True(await verifier.ExternalTracks.AnyAsync(t => t.Id == track.Id));
|
||||
}
|
||||
|
||||
private static ExternalTrack BuildExternalTrack(string externalId) => new()
|
||||
{
|
||||
Title = "External",
|
||||
NormalizedTitle = "EXTERNAL",
|
||||
DurationSeconds = 100,
|
||||
Source = TrackSource.YouTube,
|
||||
ExternalId = externalId,
|
||||
Pictures = new TrackPictures(),
|
||||
Audio = new TrackAudio()
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using Musify.Infrastructure.Services;
|
||||
using SixLabors.ImageSharp;
|
||||
using SixLabors.ImageSharp.PixelFormats;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Services;
|
||||
|
||||
public sealed class PictureServiceTests
|
||||
{
|
||||
private static PictureService CreateService() => new(NullLogger<PictureService>.Instance);
|
||||
|
||||
private static MemoryStream CreateSourceImage(int width, int height)
|
||||
{
|
||||
using var image = new Image<Rgba32>(width, height, new Rgba32(255, 0, 0));
|
||||
var stream = new MemoryStream();
|
||||
image.SaveAsPng(stream);
|
||||
stream.Position = 0;
|
||||
return stream;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_LargerThanTarget_ShrinksToFitWithinTheRequestedBox()
|
||||
{
|
||||
using var source = CreateSourceImage(800, 600);
|
||||
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 200, 200, CancellationToken.None);
|
||||
|
||||
using var result = await Image.LoadAsync(resized);
|
||||
Assert.True(result.Width <= 200);
|
||||
Assert.True(result.Height <= 200);
|
||||
Assert.True(result.Width == 200 || result.Height == 200);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_ReturnsAValidWebpStream()
|
||||
{
|
||||
using var source = CreateSourceImage(100, 100);
|
||||
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 50, 50, CancellationToken.None);
|
||||
|
||||
var format = await Image.DetectFormatAsync(resized);
|
||||
Assert.Equal("WEBP", format?.Name, ignoreCase: true);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ResizePictureAsWebpAsync_PreservesAspectRatio()
|
||||
{
|
||||
using var source = CreateSourceImage(400, 200);
|
||||
|
||||
await using var resized = await CreateService().ResizePictureAsWebpAsync(source, 100, 100, CancellationToken.None);
|
||||
|
||||
using var result = await Image.LoadAsync(resized);
|
||||
Assert.Equal(100, result.Width);
|
||||
Assert.Equal(50, result.Height);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
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(CancellationToken.None);
|
||||
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, CancellationToken.None);
|
||||
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, CancellationToken.None);
|
||||
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, CancellationToken.None);
|
||||
Assert.Null(metadata);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
using ErrorOr;
|
||||
using Microsoft.Extensions.Caching.Memory;
|
||||
using Musify.Infrastructure.Services;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Services;
|
||||
|
||||
public sealed class SingleFlightCacheTests
|
||||
{
|
||||
private static SingleFlightCache CreateCache() => new(new MemoryCache(new MemoryCacheOptions()));
|
||||
|
||||
[Fact]
|
||||
public async Task GetOrCreateAsync_SecondCallWithinDuration_ReturnsCachedValueWithoutCallingFactory()
|
||||
{
|
||||
var cache = CreateCache();
|
||||
var calls = 0;
|
||||
Task<ErrorOr<int>> Factory() { calls++; return Task.FromResult<ErrorOr<int>>(calls); }
|
||||
|
||||
var first = await cache.GetOrCreateAsync("key", TimeSpan.FromMinutes(1), Factory);
|
||||
var second = await cache.GetOrCreateAsync("key", TimeSpan.FromMinutes(1), Factory);
|
||||
|
||||
Assert.Equal(1, first.Value);
|
||||
Assert.Equal(1, second.Value);
|
||||
Assert.Equal(1, calls);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetOrCreateAsync_ConcurrentCallsForTheSameKey_CollapseIntoASingleFactoryCall()
|
||||
{
|
||||
var cache = CreateCache();
|
||||
var calls = 0;
|
||||
var gate = new TaskCompletionSource();
|
||||
|
||||
async Task<ErrorOr<int>> Factory()
|
||||
{
|
||||
Interlocked.Increment(ref calls);
|
||||
await gate.Task;
|
||||
return 7;
|
||||
}
|
||||
|
||||
var first = cache.GetOrCreateAsync("concurrent-key", TimeSpan.FromMinutes(1), Factory);
|
||||
var second = cache.GetOrCreateAsync("concurrent-key", TimeSpan.FromMinutes(1), Factory);
|
||||
gate.SetResult();
|
||||
|
||||
var results = await Task.WhenAll(first, second);
|
||||
|
||||
Assert.Equal(1, calls);
|
||||
Assert.All(results, result => Assert.Equal(7, result.Value));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetOrCreateAsync_FactoryReturnsError_DoesNotCacheIt()
|
||||
{
|
||||
var cache = CreateCache();
|
||||
var calls = 0;
|
||||
Task<ErrorOr<int>> Factory()
|
||||
{
|
||||
calls++;
|
||||
return Task.FromResult<ErrorOr<int>>(Error.Failure(description: "boom"));
|
||||
}
|
||||
|
||||
await cache.GetOrCreateAsync("error-key", TimeSpan.FromMinutes(1), Factory);
|
||||
await cache.GetOrCreateAsync("error-key", TimeSpan.FromMinutes(1), Factory);
|
||||
|
||||
Assert.Equal(2, calls);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetOrCreateAsync_NonPositiveDuration_AlwaysCallsTheFactory()
|
||||
{
|
||||
var cache = CreateCache();
|
||||
var calls = 0;
|
||||
Task<ErrorOr<int>> Factory() { calls++; return Task.FromResult<ErrorOr<int>>(calls); }
|
||||
|
||||
await cache.GetOrCreateAsync("no-cache-key", TimeSpan.Zero, Factory);
|
||||
await cache.GetOrCreateAsync("no-cache-key", TimeSpan.Zero, Factory);
|
||||
|
||||
Assert.Equal(2, calls);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
using System.Net;
|
||||
using System.Text;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
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 StorageServiceTests(InfrastructureTestFixture fixture)
|
||||
{
|
||||
private StorageService CreateService(out Musify.Infrastructure.Persistence.Database database)
|
||||
{
|
||||
database = fixture.CreateDatabase();
|
||||
var storageConfiguration = new InfrastructureStorageConfiguration
|
||||
{
|
||||
Address = fixture.S3ServiceUrl,
|
||||
AccessKey = InfrastructureTestFixture.S3AccessKey,
|
||||
SecretAccessKey = InfrastructureTestFixture.S3SecretKey,
|
||||
ForcePathStyle = true,
|
||||
UseHttp = true,
|
||||
};
|
||||
return new StorageService(database, fixture.CreateS3Client(), NullLogger<StorageService>.Instance, storageConfiguration);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UploadThenGetFile_RoundTripsTheSameBytes()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
var key = $"tests/{Guid.NewGuid():N}/round-trip.txt";
|
||||
var content = "hello seaweedfs"u8.ToArray();
|
||||
|
||||
await service.UploadFileAsync(new MemoryStream(content), "text/plain", InfrastructureTestFixture.S3Bucket, key, CancellationToken.None);
|
||||
|
||||
await using var stream = await service.GetFileAsync(InfrastructureTestFixture.S3Bucket, key, CancellationToken.None);
|
||||
using var reader = new StreamReader(stream, Encoding.UTF8);
|
||||
var readBack = await reader.ReadToEndAsync();
|
||||
|
||||
Assert.Equal("hello seaweedfs", readBack);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task HeadObjectAsync_ExistingObject_ReturnsMetadata()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
var key = $"tests/{Guid.NewGuid():N}/head.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("x"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, key, CancellationToken.None);
|
||||
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, CancellationToken.None);
|
||||
|
||||
Assert.NotNull(metadata);
|
||||
Assert.Equal(1, metadata.ContentLength);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task HeadObjectAsync_MissingObject_ReturnsNull()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, $"tests/{Guid.NewGuid():N}/missing.txt", CancellationToken.None);
|
||||
|
||||
Assert.Null(metadata);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task RemoveFileAsync_ExistingObject_DeletesIt()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
var key = $"tests/{Guid.NewGuid():N}/to-remove.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("x"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, key, CancellationToken.None);
|
||||
|
||||
await service.RemoveFileAsync(InfrastructureTestFixture.S3Bucket, key, CancellationToken.None);
|
||||
|
||||
Assert.Null(await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, CancellationToken.None));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CopyFileAsync_CopiesToTheDestinationKey()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
var sourceKey = $"tests/{Guid.NewGuid():N}/source.txt";
|
||||
var destinationKey = $"tests/{Guid.NewGuid():N}/destination.txt";
|
||||
await service.UploadFileAsync(new MemoryStream("copy-me"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, sourceKey, CancellationToken.None);
|
||||
|
||||
await service.CopyFileAsync(InfrastructureTestFixture.S3Bucket, sourceKey, InfrastructureTestFixture.S3Bucket, destinationKey, CancellationToken.None);
|
||||
|
||||
Assert.NotNull(await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, destinationKey, CancellationToken.None));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ListObjectsAsync_ReturnsEveryObjectUnderThePrefix()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
var prefix = $"tests/{Guid.NewGuid():N}";
|
||||
await service.UploadFileAsync(new MemoryStream("a"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/a.txt", CancellationToken.None);
|
||||
await service.UploadFileAsync(new MemoryStream("b"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/b.txt", CancellationToken.None);
|
||||
|
||||
var keys = new List<string>();
|
||||
await foreach (var item in service.ListObjectsAsync(InfrastructureTestFixture.S3Bucket, prefix, CancellationToken.None))
|
||||
keys.Add(item.Key);
|
||||
|
||||
Assert.Equal([$"{prefix}/a.txt", $"{prefix}/b.txt"], keys.Order());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task RemoveFolderAsync_DeletesEveryObjectUnderThePrefix()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
var prefix = $"tests/{Guid.NewGuid():N}";
|
||||
await service.UploadFileAsync(new MemoryStream("a"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/a.txt", CancellationToken.None);
|
||||
await service.UploadFileAsync(new MemoryStream("b"u8.ToArray()), "text/plain", InfrastructureTestFixture.S3Bucket, $"{prefix}/nested/b.txt", CancellationToken.None);
|
||||
|
||||
await service.RemoveFolderAsync(InfrastructureTestFixture.S3Bucket, prefix, CancellationToken.None);
|
||||
|
||||
var remaining = new List<string>();
|
||||
await foreach (var item in service.ListObjectsAsync(InfrastructureTestFixture.S3Bucket, prefix, CancellationToken.None))
|
||||
remaining.Add(item.Key);
|
||||
Assert.Empty(remaining);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task GetUploadUrlAsync_PresignedPut_CanActuallyUploadTheObject()
|
||||
{
|
||||
var service = CreateService(out var database);
|
||||
await using var _ = database;
|
||||
var key = $"tests/{Guid.NewGuid():N}/presigned.txt";
|
||||
|
||||
var uploadUrl = await service.GetUploadUrlAsync(
|
||||
InfrastructureTestFixture.S3Bucket, key, "text/plain", TimeSpan.FromMinutes(5), CancellationToken.None);
|
||||
|
||||
using var httpClient = new HttpClient();
|
||||
using var request = new HttpRequestMessage(HttpMethod.Put, uploadUrl)
|
||||
{
|
||||
// Not StringContent: it appends "; charset=utf-8" to Content-Type, which no longer
|
||||
// matches the "text/plain" the presigned URL's signature was computed over (SigV4
|
||||
// signs Content-Type byte-for-byte) and the server answers 403 SignatureDoesNotMatch.
|
||||
Content = new ByteArrayContent(Encoding.UTF8.GetBytes("presigned content"))
|
||||
};
|
||||
request.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("text/plain");
|
||||
// GetUploadUrlAsync defaults preventOverwrite to true, which signs the URL together with
|
||||
// this header (see StorageService.GetUploadUrlAsync) — the actual PUT has to send it too,
|
||||
// or the signature no longer matches and the server answers 403.
|
||||
request.Headers.TryAddWithoutValidation("If-None-Match", "*");
|
||||
var response = await httpClient.SendAsync(request);
|
||||
var responseBody = await response.Content.ReadAsStringAsync();
|
||||
|
||||
Assert.True(response.StatusCode == HttpStatusCode.OK, $"status={response.StatusCode}, body={responseBody}");
|
||||
var metadata = await service.HeadObjectAsync(InfrastructureTestFixture.S3Bucket, key, CancellationToken.None);
|
||||
Assert.NotNull(metadata);
|
||||
Assert.Equal("presigned content".Length, metadata.ContentLength);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using System.Security.Cryptography;
|
||||
using Microsoft.IdentityModel.JsonWebTokens;
|
||||
using Microsoft.IdentityModel.Tokens;
|
||||
using Musify.Infrastructure.Configuration;
|
||||
using Musify.Infrastructure.Services;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.Services;
|
||||
|
||||
public sealed class StreamTicketServiceTests : IDisposable
|
||||
{
|
||||
private readonly string privateKeyPath = Path.GetTempFileName();
|
||||
private readonly RSA rsa = RSA.Create(2048);
|
||||
|
||||
public StreamTicketServiceTests() => File.WriteAllText(privateKeyPath, rsa.ExportPkcs8PrivateKeyPem());
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
rsa.Dispose();
|
||||
File.Delete(privateKeyPath);
|
||||
}
|
||||
|
||||
private StreamTicketService CreateService(int ticketTtlSeconds = 3600) => new(new StreamTicketConfiguration
|
||||
{
|
||||
PrivateKeyPath = privateKeyPath,
|
||||
Audience = "media-gateway",
|
||||
Issuer = "musify-webapi",
|
||||
TicketTtlSeconds = ticketTtlSeconds
|
||||
});
|
||||
|
||||
[Fact]
|
||||
public void IssueTicket_ReturnsATokenSignedWithTheConfiguredKeyAndClaims()
|
||||
{
|
||||
using var service = CreateService(ticketTtlSeconds: 120);
|
||||
|
||||
var ticket = service.IssueTicket(userId: 42, keyPrefix: "Tracks/ProcessedAudios/abc/");
|
||||
|
||||
Assert.Equal(120, ticket.ExpiresInSeconds);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var jwt = handler.ReadJsonWebToken(ticket.Token);
|
||||
Assert.Equal("42", jwt.GetClaim("sub").Value);
|
||||
Assert.Equal("Tracks/ProcessedAudios/abc/", jwt.GetClaim("prefix").Value);
|
||||
Assert.Equal("musify-webapi", jwt.Issuer);
|
||||
Assert.Contains("media-gateway", jwt.Audiences);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task IssueTicket_TokenValidatesAgainstTheMatchingPublicKey()
|
||||
{
|
||||
using var service = CreateService();
|
||||
var ticket = service.IssueTicket(userId: 1, keyPrefix: "Tracks/ProcessedAudios/xyz/");
|
||||
|
||||
var publicKeyPem = rsa.ExportSubjectPublicKeyInfoPem();
|
||||
using var verifyingRsa = RSA.Create();
|
||||
verifyingRsa.ImportFromPem(publicKeyPem);
|
||||
|
||||
var handler = new JsonWebTokenHandler();
|
||||
var result = await handler.ValidateTokenAsync(ticket.Token, new TokenValidationParameters
|
||||
{
|
||||
ValidIssuer = "musify-webapi",
|
||||
ValidAudience = "media-gateway",
|
||||
ValidateIssuer = true,
|
||||
ValidateAudience = true,
|
||||
ValidateLifetime = true,
|
||||
IssuerSigningKey = new RsaSecurityKey(verifyingRsa),
|
||||
});
|
||||
|
||||
Assert.True(result.IsValid);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
using System.Text.Json;
|
||||
using Amazon.S3;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Musify.Infrastructure.Configuration;
|
||||
using Musify.Infrastructure.Persistence;
|
||||
using Testcontainers.PostgreSql;
|
||||
using DotNet.Testcontainers.Builders;
|
||||
using DotNet.Testcontainers.Containers;
|
||||
using Xunit;
|
||||
|
||||
namespace Musify.Infrastructure.Tests.TestSupport;
|
||||
|
||||
/// <summary>
|
||||
/// One Postgres container and one SeaweedFS container (same image and startup
|
||||
/// command as <c>deploy/compose.yml</c>), started once for every test in the
|
||||
/// <see cref="InfrastructureCollection"/> and torn down when the run finishes.
|
||||
/// EF Core migrations run once here too, against the real <c>Database</c>
|
||||
/// DbContext, so a broken migration fails the whole run immediately.
|
||||
/// </summary>
|
||||
public sealed class InfrastructureTestFixture : IAsyncLifetime
|
||||
{
|
||||
public const string S3AccessKey = "musify-test";
|
||||
public const string S3SecretKey = "musify-test-secret";
|
||||
public const string S3Bucket = "musify-test-bucket";
|
||||
|
||||
private readonly PostgreSqlContainer postgres = new PostgreSqlBuilder("postgres:17-alpine")
|
||||
.WithDatabase("musify_test")
|
||||
.WithUsername("postgres")
|
||||
.WithPassword("postgres")
|
||||
.Build();
|
||||
|
||||
private readonly IContainer seaweedFs = new ContainerBuilder("chrislusf/seaweedfs:latest")
|
||||
.WithEntrypoint("/bin/sh", "-c")
|
||||
.WithCommand(BuildSeaweedFsStartupScript())
|
||||
.WithPortBinding(9333, assignRandomHostPort: true)
|
||||
.WithPortBinding(8333, assignRandomHostPort: true)
|
||||
.WithWaitStrategy(Wait.ForUnixContainer()
|
||||
.UntilHttpRequestIsSucceeded(request => request.ForPort(9333).ForPath("/cluster/healthz")))
|
||||
.Build();
|
||||
|
||||
public string ConnectionString => postgres.GetConnectionString();
|
||||
|
||||
public string S3ServiceUrl => $"http://{seaweedFs.Hostname}:{seaweedFs.GetMappedPublicPort(8333)}";
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
await Task.WhenAll(postgres.StartAsync(), seaweedFs.StartAsync());
|
||||
|
||||
await using var database = new Database(new DatabaseConfiguration { ConnectionString = ConnectionString });
|
||||
await database.Database.MigrateAsync();
|
||||
|
||||
// SeaweedFS does not auto-create buckets (see deploy/compose.yml's seaweedfs-init).
|
||||
using var s3 = CreateS3Client();
|
||||
await s3.PutBucketAsync(S3Bucket);
|
||||
}
|
||||
|
||||
public async Task DisposeAsync()
|
||||
{
|
||||
await postgres.DisposeAsync();
|
||||
await seaweedFs.DisposeAsync();
|
||||
}
|
||||
|
||||
/// <summary>A fresh, DI-wired <see cref="Database"/>, so <c>AuditableEntityInterceptor</c>
|
||||
/// (attached in <c>AddDatabase</c>'s DI registration, not in the class itself) is active —
|
||||
/// same wiring the real app uses, not a bare <c>new Database(...)</c>.</summary>
|
||||
public Database CreateDatabase()
|
||||
{
|
||||
var configuration = new ConfigurationBuilder()
|
||||
.AddInMemoryCollection([new("Database:ConnectionString", ConnectionString)])
|
||||
.Build();
|
||||
|
||||
var services = new ServiceCollection();
|
||||
services.AddDatabase(configuration);
|
||||
return services.BuildServiceProvider().GetRequiredService<Database>();
|
||||
}
|
||||
|
||||
/// <summary>An <see cref="IAmazonS3"/> client configured exactly like
|
||||
/// <c>ServicesDependencyInjection.AddStorageService</c>, pointed at the SeaweedFS container.</summary>
|
||||
public IAmazonS3 CreateS3Client() =>
|
||||
new AmazonS3Client(S3AccessKey, S3SecretKey, new AmazonS3Config
|
||||
{
|
||||
ServiceURL = S3ServiceUrl,
|
||||
ForcePathStyle = true,
|
||||
UseHttp = true,
|
||||
});
|
||||
|
||||
private static string BuildSeaweedFsStartupScript()
|
||||
{
|
||||
var identity = JsonSerializer.Serialize(new
|
||||
{
|
||||
identities = new[]
|
||||
{
|
||||
new
|
||||
{
|
||||
name = "musify-test",
|
||||
credentials = new[] { new { accessKey = S3AccessKey, secretKey = S3SecretKey } },
|
||||
actions = new[] { "Admin", "Read", "Write" }
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return $"""
|
||||
cat > /tmp/s3.conf <<'JSON'
|
||||
{identity}
|
||||
JSON
|
||||
exec weed server -ip.bind=0.0.0.0 -dir=/data -master.volumeSizeLimitMB=1024 -volume.max=0 -filer -s3 -s3.config=/tmp/s3.conf
|
||||
""";
|
||||
}
|
||||
}
|
||||
|
||||
[CollectionDefinition(Name)]
|
||||
public sealed class InfrastructureCollection : ICollectionFixture<InfrastructureTestFixture>
|
||||
{
|
||||
public const string Name = "Infrastructure";
|
||||
}
|
||||
Reference in New Issue
Block a user