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

using MassTransit;
using MassTransit.Courier.Contracts;
using MassTransit.Testing;
using Microsoft.Extensions.DependencyInjection;
using Musify.Application.Events;
using Musify.Infrastructure.MassTransit.Consumers;
using Musify.Infrastructure.MassTransit.RoutingSlip;
using Xunit;

namespace Musify.Infrastructure.Tests.MassTransit;

public sealed class ProcessingSlipFaultConsumerTests
{
    private static readonly Guid SubjectId = Guid.NewGuid();

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

    [Fact]
    public async Task Consume_TrackPicture_PublishesTrackPictureProcessingFailed() =>
        await AssertPublishedAsync<TrackPictureProcessingFailed>(
            RoutingSlipVariableNames.ProcessKinds.TrackPicture, message => message.TrackId == SubjectId);

    [Fact]
    public async Task Consume_TrackAudio_PublishesTrackAudioProcessingFailed() =>
        await AssertPublishedAsync<TrackAudioProcessingFailed>(
            RoutingSlipVariableNames.ProcessKinds.TrackAudio, message => message.TrackId == SubjectId);

    [Fact]
    public async Task Consume_PlayListPicture_PublishesPlayListPictureProcessingFailed() =>
        await AssertPublishedAsync<PlayListPictureProcessingFailed>(
            RoutingSlipVariableNames.ProcessKinds.PlayListPicture, message => message.PlayListId == SubjectId);

    [Fact]
    public async Task Consume_AlbumPicture_PublishesAlbumPictureProcessingFailed() =>
        await AssertPublishedAsync<AlbumPictureProcessingFailed>(
            RoutingSlipVariableNames.ProcessKinds.AlbumPicture, message => message.AlbumId == SubjectId);

    [Fact]
    public async Task Consume_TrackCreation_PublishesTrackProcessingFailedWithKeys() =>
        await AssertPublishedAsync<TrackProcessingFailed>(
            RoutingSlipVariableNames.ProcessKinds.TrackCreation,
            message => message is { Bucket: "bucket", PictureKey: "picture-key", AudioKey: "audio-key" } && message.TrackId == SubjectId);

    [Fact]
    public async Task Consume_AlbumCreation_PublishesAlbumProcessingFailedWithKeys() =>
        await AssertPublishedAsync<AlbumProcessingFailed>(
            RoutingSlipVariableNames.ProcessKinds.AlbumCreation,
            message => message is { Bucket: "bucket", PictureKey: "picture-key" } && message.AlbumId == SubjectId);

    [Fact]
    public async Task Consume_PlayListCreation_PublishesPlayListProcessingFailedWithKeys() =>
        await AssertPublishedAsync<PlayListProcessingFailed>(
            RoutingSlipVariableNames.ProcessKinds.PlayListCreation,
            message => message is { Bucket: "bucket", PictureKey: "picture-key" } && message.PlayListId == SubjectId);

    [Fact]
    public async Task Consume_UnknownKind_PublishesNothing()
    {
        await using var provider = CreateProvider();
        var harness = provider.GetRequiredService<ITestHarness>();
        await harness.Start();

        await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = Variables("Something else") }, Ct);

        Assert.True(await harness.Consumed.Any<RoutingSlipFaulted>(Ct));
        Assert.False(await harness.Published.Any<TrackPictureProcessingFailed>(Ct));
        Assert.False(await harness.Published.Any<TrackProcessingFailed>(Ct));
    }

    [Fact]
    public async Task Consume_WithoutProcessKind_PublishesNothing()
    {
        await using var provider = CreateProvider();
        var harness = provider.GetRequiredService<ITestHarness>();
        await harness.Start();

        await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = new Dictionary<string, object>() }, Ct);

        Assert.True(await harness.Consumed.Any<RoutingSlipFaulted>(Ct));
        Assert.False(await harness.Published.Any<TrackPictureProcessingFailed>(Ct));
    }

    private static async Task AssertPublishedAsync<TEvent>(string processKind, Func<TEvent, bool> matches)
        where TEvent : class
    {
        await using var provider = CreateProvider();
        var harness = provider.GetRequiredService<ITestHarness>();
        await harness.Start();

        await harness.Bus.Publish<RoutingSlipFaulted>(new { Variables = Variables(processKind) }, Ct);

        Assert.True(await harness.Published.Any<TEvent>(published => matches(published.Context.Message), Ct));
    }

    private static Dictionary<string, object> Variables(string processKind) => new()
    {
        [RoutingSlipVariableNames.Workflow.ProcessKind] = processKind,
        [RoutingSlipVariableNames.Workflow.SubjectId] = SubjectId,
        [RoutingSlipVariableNames.Workflow.Bucket] = "bucket",
        [RoutingSlipVariableNames.Workflow.PictureKey] = "picture-key",
        [RoutingSlipVariableNames.Workflow.AudioKey] = "audio-key",
    };

    private static ServiceProvider CreateProvider() =>
        new ServiceCollection()
            .AddMassTransitTestHarness(bus => bus.AddConsumer<ProcessingSlipFaultConsumer>())
            .BuildServiceProvider(true);
}