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

using MassTransit;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using Musify.Domain.Entities;
using Musify.Domain.ValueObjects;
using Musify.Infrastructure.MassTransit.Activities.LifeCycle;
using Musify.Infrastructure.MassTransit.Arguments;
using Musify.Infrastructure.Tests.TestSupport;
using NSubstitute;
using Xunit;

namespace Musify.Infrastructure.Tests.MassTransit;

[Collection(InfrastructureCollection.Name)]
public sealed class LifeCycleActivityTests(InfrastructureTestFixture fixture)
{
    private static CancellationToken Ct => TestContext.Current.CancellationToken;

    [Fact]
    public async Task MarkTrack_ExistingTrack_SetsTheStatus()
    {
        var track = await SeedTrackAsync();
        await using var database = fixture.CreateDatabase();
        var activity = new MarkTrackLifeCycleActivity(database, NullLogger<MarkTrackLifeCycleActivity>.Instance);
        var context = ExecuteContextFor(new MarkLifeCycleArguments(track.Id, LifeCycleStatus.Removing));

        await activity.Execute(context);

        context.Received(1).Completed();
        await using var verifier = fixture.CreateDatabase();
        var stored = await verifier.Tracks.AsNoTracking().SingleAsync(t => t.Id == track.Id, Ct);
        Assert.Equal(LifeCycleStatus.Removing, stored.LifeCycleStatus);
    }

    [Fact]
    public async Task MarkAlbum_ExistingAlbum_SetsTheStatus()
    {
        var album = await SeedAlbumAsync();
        await using var database = fixture.CreateDatabase();
        var activity = new MarkAlbumLifeCycleActivity(database, NullLogger<MarkAlbumLifeCycleActivity>.Instance);

        await activity.Execute(ExecuteContextFor(new MarkLifeCycleArguments(album.Id, LifeCycleStatus.Failed)));

        await using var verifier = fixture.CreateDatabase();
        Assert.Equal(LifeCycleStatus.Failed, (await verifier.Albums.AsNoTracking().SingleAsync(a => a.Id == album.Id, Ct)).LifeCycleStatus);
    }

    [Fact]
    public async Task MarkPlayList_ExistingPlayList_SetsTheStatus()
    {
        var playList = await SeedPlayListAsync();
        await using var database = fixture.CreateDatabase();
        var activity = new MarkPlayListLifeCycleActivity(database, NullLogger<MarkPlayListLifeCycleActivity>.Instance);

        await activity.Execute(ExecuteContextFor(new MarkLifeCycleArguments(playList.Id, LifeCycleStatus.Removing)));

        await using var verifier = fixture.CreateDatabase();
        Assert.Equal(LifeCycleStatus.Removing, (await verifier.PlayLists.AsNoTracking().SingleAsync(p => p.Id == playList.Id, Ct)).LifeCycleStatus);
    }

    [Fact]
    public async Task Mark_MissingEntity_CompletesWithoutFailing()
    {
        await using var database = fixture.CreateDatabase();
        var activity = new MarkTrackLifeCycleActivity(database, NullLogger<MarkTrackLifeCycleActivity>.Instance);
        var context = ExecuteContextFor(new MarkLifeCycleArguments(Guid.NewGuid(), LifeCycleStatus.Failed));

        await activity.Execute(context);

        context.Received(1).Completed();
    }

    [Fact]
    public async Task DeleteTrack_ExistingTrack_RemovesTheRow()
    {
        var track = await SeedTrackAsync();
        await using var database = fixture.CreateDatabase();
        var activity = new DeleteTrackActivity(database, NullLogger<DeleteTrackActivity>.Instance);
        var context = ExecuteContextFor(new DeleteEntityArguments(track.Id));

        await activity.Execute(context);

        context.Received(1).Completed();
        await using var verifier = fixture.CreateDatabase();
        Assert.False(await verifier.Tracks.AnyAsync(t => t.Id == track.Id, Ct));
    }

    [Fact]
    public async Task DeleteAlbum_ExistingAlbum_RemovesTheRow()
    {
        var album = await SeedAlbumAsync();
        await using var database = fixture.CreateDatabase();
        var activity = new DeleteAlbumActivity(database, NullLogger<DeleteAlbumActivity>.Instance);

        await activity.Execute(ExecuteContextFor(new DeleteEntityArguments(album.Id)));

        await using var verifier = fixture.CreateDatabase();
        Assert.False(await verifier.Albums.AnyAsync(a => a.Id == album.Id, Ct));
    }

    [Fact]
    public async Task DeletePlayList_ExistingPlayList_RemovesTheRow()
    {
        var playList = await SeedPlayListAsync();
        await using var database = fixture.CreateDatabase();
        var activity = new DeletePlayListActivity(database, NullLogger<DeletePlayListActivity>.Instance);

        await activity.Execute(ExecuteContextFor(new DeleteEntityArguments(playList.Id)));

        await using var verifier = fixture.CreateDatabase();
        Assert.False(await verifier.PlayLists.AnyAsync(p => p.Id == playList.Id, Ct));
    }

    [Fact]
    public async Task Delete_MissingEntity_CompletesWithoutFailing()
    {
        await using var database = fixture.CreateDatabase();
        var activity = new DeleteTrackActivity(database, NullLogger<DeleteTrackActivity>.Instance);
        var context = ExecuteContextFor(new DeleteEntityArguments(Guid.NewGuid()));

        await activity.Execute(context);

        context.Received(1).Completed();
    }

    private static ExecuteContext<TArguments> ExecuteContextFor<TArguments>(TArguments arguments)
        where TArguments : class
    {
        var context = Substitute.For<ExecuteContext<TArguments>>();
        context.Arguments.Returns(arguments);
        context.CancellationToken.Returns(Ct);
        return context;
    }

    private async Task<User> SeedUserAsync()
    {
        await using var database = fixture.CreateDatabase();
        var name = $"lifecycle-{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<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(),
            Audio = new TrackAudio()
        };
        await database.Tracks.AddAsync(track, Ct);
        await database.SaveChangesAsync(Ct);
        return track;
    }

    private async Task<Album> SeedAlbumAsync()
    {
        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 };
        await database.Albums.AddAsync(album, Ct);
        await database.SaveChangesAsync(Ct);
        return album;
    }

    private async Task<PlayList> SeedPlayListAsync()
    {
        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 };
        await database.PlayLists.AddAsync(playList, Ct);
        await database.SaveChangesAsync(Ct);
        return playList;
    }
}