Musify/backend/Tests/Musify.Infrastructure.Tests/MassTransit/UpdatePicturesActivityTests.cs

using MassTransit;
using MassTransit.Courier.Contracts;
using MassTransit.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Musify.Application.Contracts;
using Musify.Application.Events;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
using Musify.Infrastructure.MassTransit.Activities.Pictures;
using Musify.Infrastructure.MassTransit.Arguments;
using Musify.Infrastructure.MassTransit.Logs;
using Musify.Infrastructure.MassTransit.RoutingSlip;
using Musify.Infrastructure.Tests.TestSupport;
using Xunit;

namespace Musify.Infrastructure.Tests.MassTransit;

/// <summary>Runs the picture-update activities inside real routing slips on the MassTransit test harness.</summary>
[Collection(InfrastructureCollection.Name)]
public sealed class UpdatePicturesActivityTests(InfrastructureTestFixture fixture)
{
    private const string SmallVariable = "Picture.Small";
    private const string MediumVariable = "Picture.Medium";
    private const string LargeVariable = "Picture.Large";

    private static CancellationToken Ct => TestContext.Current.CancellationToken;

    [Fact]
    public async Task Album_Execute_StoresTheNamesAndPublishesTheEvent()
    {
        var album = await SeedAlbumAsync(EntityPictures.Pending("old-original.webp"));
        await using var provider = CreateProvider();
        var harness = await StartAsync(provider);

        var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, album.Id, "uploads/1/albums/new-original.webp");
        await harness.Bus.Execute(slip.Build(), Ct);

        Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
        await using var verifier = fixture.CreateDatabase();
        var stored = (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!;
        Assert.Equal("new-original.webp", stored.OriginalName);
        Assert.Equal("small.webp", stored.SmallName);
        Assert.Equal("medium.webp", stored.MediumName);
        Assert.Equal("large.webp", stored.LargeName);
        Assert.True(await harness.Published.Any<AlbumPictureProcessed>(published => published.Context.Message.AlbumId == album.Id, Ct));
    }

    [Fact]
    public async Task PlayList_Execute_StoresTheNamesAndPublishesTheEvent()
    {
        var playList = await SeedPlayListAsync(EntityPictures.Pending("old.webp"));
        await using var provider = CreateProvider();
        var harness = await StartAsync(provider);

        var slip = SlipFor(UpdatePlayListPictureActivity.ExecuteEndpointName, playList.Id, "uploads/1/playlists/new.webp");
        await harness.Bus.Execute(slip.Build(), Ct);

        Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
        await using var verifier = fixture.CreateDatabase();
        var stored = (await verifier.PlayLists.AsNoTracking().SingleAsync(p => p.Id == playList.Id, Ct)).Pictures!;
        Assert.Equal("new.webp", stored.OriginalName);
        Assert.Equal("small.webp", stored.SmallName);
        Assert.True(await harness.Published.Any<PlayListPictureProcessed>(published => published.Context.Message.PlayListId == playList.Id, Ct));
    }

    [Fact]
    public async Task Track_Execute_MarksThePicturesAsCompleted()
    {
        var track = await SeedTrackAsync();
        await using var provider = CreateProvider();
        var harness = await StartAsync(provider);

        var slip = SlipFor(UpdateTrackPictureActivity.ExecuteEndpointName, track.Id, "uploads/1/tracks/new.webp");
        await harness.Bus.Execute(slip.Build(), Ct);

        Assert.True(await harness.Sent.Any<RoutingSlipCompleted>(Ct));
        await using var verifier = fixture.CreateDatabase();
        var stored = (await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures;
        Assert.Equal(ProcessingStatus.Completed, stored.ProcessingStatus);
        Assert.Equal("large.webp", stored.LargeName);
        Assert.True(await harness.Published.Any<TrackPictureProcessed>(published => published.Context.Message.TrackId == track.Id, Ct));
    }

    [Fact]
    public async Task Execute_MissingEntity_FaultsTheSlip()
    {
        await using var provider = CreateProvider();
        var harness = await StartAsync(provider);

        var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, Guid.NewGuid(), "uploads/1/albums/x.webp");
        await harness.Bus.Execute(slip.Build(), Ct);

        Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
    }

    [Fact]
    public async Task Execute_MissingVariable_FaultsTheSlip()
    {
        var album = await SeedAlbumAsync(EntityPictures.Pending("old.webp"));
        await using var provider = CreateProvider();
        var harness = await StartAsync(provider);

        var slip = RoutingSlips.Create(null).AddStep(
            "Update",
            UpdateAlbumPictureActivity.ExecuteEndpointName,
            new UpdatePicturesArguments(album.Id, "key.webp", SmallVariable, MediumVariable, LargeVariable));
        await harness.Bus.Execute(slip.Build(), Ct);

        Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
        await using var verifier = fixture.CreateDatabase();
        Assert.Equal("old.webp", (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!.OriginalName);
    }

    [Fact]
    public async Task Album_LaterStepFails_CompensationRestoresThePreviousNames()
    {
        var album = await SeedAlbumAsync(EntityPictures.Pending("old-original.webp"));
        await using var provider = CreateProvider();
        var harness = await StartAsync(provider);

        var slip = SlipFor(UpdateAlbumPictureActivity.ExecuteEndpointName, album.Id, "uploads/1/albums/new-original.webp");
        slip.AddStep("Fail", AlwaysFailsActivity.ExecuteEndpointName, new AlwaysFailsArguments());
        await harness.Bus.Execute(slip.Build(), Ct);

        Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
        await WaitUntilAsync(async () =>
        {
            await using var poll = fixture.CreateDatabase();
            return (await poll.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!.OriginalName == "old-original.webp";
        });
        await using var verifier = fixture.CreateDatabase();
        var stored = (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).Pictures!;
        Assert.Equal("old-original.webp", stored.OriginalName);
        Assert.Null(stored.SmallName);
        Assert.Null(stored.MediumName);
        Assert.Null(stored.LargeName);
    }

    [Fact]
    public async Task Track_LaterStepFails_CompensationMarksThePicturesAsFailed()
    {
        var track = await SeedTrackAsync();
        await using var provider = CreateProvider();
        var harness = await StartAsync(provider);

        var slip = SlipFor(UpdateTrackPictureActivity.ExecuteEndpointName, track.Id, "uploads/1/tracks/new.webp");
        slip.AddStep("Fail", AlwaysFailsActivity.ExecuteEndpointName, new AlwaysFailsArguments());
        await harness.Bus.Execute(slip.Build(), Ct);

        Assert.True(await harness.Sent.Any<RoutingSlipFaulted>(Ct));
        await WaitUntilAsync(async () =>
        {
            await using var poll = fixture.CreateDatabase();
            return (await poll.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures.ProcessingStatus == ProcessingStatus.Failed;
        });
        await using var verifier = fixture.CreateDatabase();
        var stored = (await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct)).Pictures;
        Assert.Equal(ProcessingStatus.Failed, stored.ProcessingStatus);
        Assert.Equal("old.webp", stored.OriginalName);
    }

    private static async Task WaitUntilAsync(Func<Task<bool>> condition)
    {
        var deadline = DateTime.UtcNow.AddSeconds(10);
        while (!await condition() && DateTime.UtcNow < deadline)
            await Task.Delay(100, Ct);
    }

    private static RoutingSlipBuilder SlipFor(string endpointName, Guid subjectId, string originalKey)
    {
        var builder = RoutingSlips.Create(null).AddStep(
            "Update", endpointName, new UpdatePicturesArguments(subjectId, originalKey, SmallVariable, MediumVariable, LargeVariable));
        builder.AddVariable(SmallVariable, "pictures/small.webp");
        builder.AddVariable(MediumVariable, "pictures/medium.webp");
        builder.AddVariable(LargeVariable, "pictures/large.webp");
        return builder;
    }

    private ServiceProvider CreateProvider() =>
        new ServiceCollection()
            .AddScoped<IDatabase>(_ => fixture.CreateDatabase())
            .AddMassTransitTestHarness(bus =>
            {
                bus.SetKebabCaseEndpointNameFormatter();
                bus.AddActivity<UpdateAlbumPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
                bus.AddActivity<UpdatePlayListPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
                bus.AddActivity<UpdateTrackPictureActivity, UpdatePicturesArguments, UpdatePicturesLog>();
                bus.AddExecuteActivity<AlwaysFailsActivity, AlwaysFailsArguments>();
            })
            .BuildServiceProvider(true);

    private static async Task<ITestHarness> StartAsync(ServiceProvider provider)
    {
        var harness = provider.GetRequiredService<ITestHarness>();
        await harness.Start();
        return harness;
    }

    private async Task<User> SeedUserAsync()
    {
        await using var database = fixture.CreateDatabase();
        var name = $"pictures-{Guid.NewGuid():N}"[..30];
        var user = new User { Id = Random.Shared.NextInt64(1, long.MaxValue), Name = name, NormalizedName = name.ToUpperInvariant() };
        await database.Users.AddAsync(user, Ct);
        await database.SaveChangesAsync(Ct);
        return user;
    }

    private async Task<Album> SeedAlbumAsync(EntityPictures pictures)
    {
        var user = await SeedUserAsync();
        await using var database = fixture.CreateDatabase();
        var title = $"album-{Guid.NewGuid():N}";
        var album = new Album { Title = title, NormalizedTitle = title.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
        await database.Albums.AddAsync(album, Ct);
        await database.SaveChangesAsync(Ct);
        return album;
    }

    private async Task<PlayList> SeedPlayListAsync(EntityPictures pictures)
    {
        var user = await SeedUserAsync();
        await using var database = fixture.CreateDatabase();
        var name = $"pl-{Guid.NewGuid():N}"[..30];
        var playList = new PlayList { Name = name, NormalizedName = name.ToUpperInvariant(), OwnerUserId = user.Id, Pictures = pictures };
        await database.PlayLists.AddAsync(playList, Ct);
        await database.SaveChangesAsync(Ct);
        return playList;
    }

    private async Task<Track> SeedTrackAsync()
    {
        var user = await SeedUserAsync();
        await using var database = fixture.CreateDatabase();
        var title = $"track-{Guid.NewGuid():N}";
        var track = new Track
        {
            Title = title,
            NormalizedTitle = title.ToUpperInvariant(),
            DurationSeconds = 10,
            OwnerUserId = user.Id,
            Pictures = new TrackPictures { OriginalName = "old.webp" },
            Audio = new TrackAudio()
        };
        await database.Tracks.AddAsync(track, Ct);
        await database.SaveChangesAsync(Ct);
        return track;
    }

    public sealed record AlwaysFailsArguments;

    public sealed class AlwaysFailsActivity : IExecuteActivity<AlwaysFailsArguments>
    {
        public const string ExecuteEndpointName = "always-fails";

        public Task<ExecutionResult> Execute(ExecuteContext<AlwaysFailsArguments> context) =>
            throw new InvalidOperationException("Forced failure");
    }
}