Musify/backend/Tests/Musify.Application.Tests/Tracks/CreateTrackCommandHandlerTests.cs

using ErrorOr;
using Musify.Application.Contracts;
using Musify.Application.Services;
using Musify.Application.Tests.TestSupport;
using Musify.Application.Tracks;
using Musify.Domain.ValueObjects;
using NSubstitute;
using Xunit;

namespace Musify.Application.Tests.Tracks;

public sealed class CreateTrackCommandHandlerTests : HandlerTestBase
{
    private readonly IEventBus eventBus = Substitute.For<IEventBus>();
    private readonly IStorageService storageService = Substitute.For<IStorageService>();

    private CreateTrackCommandHandler CreateHandler()
    {
        storageService
            .HeadObjectAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
            .Returns(new ObjectMetaData("image/webp", 1024));

        return new CreateTrackCommandHandler(
            Database,
            eventBus,
            new UploadIntentValidator(Database, storageService),
            NoOpLogger<CreateTrackCommandHandler>(),
            TestConfigurations.Storage(),
            TestConfigurations.Track(),
            TestConfigurations.UploadIntent());
    }

    private static (Domain.Entities.UploadIntent Picture, Domain.Entities.UploadIntent Audio) SeedIntents(long userId) =>
        (TestEntities.UploadIntent(userId, UploadIntentPurpose.TrackPicture, objectName: "cover.webp"),
         TestEntities.UploadIntent(userId, UploadIntentPurpose.TrackAudio, objectName: "song.mp3"));

    [Fact]
    public async Task Handle_ValidIntents_CreatesTrackAndPublishesEvent()
    {
        var user = TestEntities.User();
        var (picture, audio) = SeedIntents(user.Id);
        await SeedAsync(user, picture, audio);

        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id);

        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);

        Assert.False(result.IsError);
        Assert.Equal("My Song", result.Value.Title);
        Assert.Equal(user.Id, result.Value.OwnerUserId);
        await eventBus.Received(1).PublishAsync(Arg.Any<Musify.Application.Events.CreateTrackResourcesEvent>(), Arg.Any<CancellationToken>());

        var stored = await Database.LocalTracks.FindAsync([result.Value.Id], TestContext.Current.CancellationToken);
        Assert.NotNull(stored);
        Assert.Equal(ProcessingStatus.Pending, stored.Audio.TranscodeStatus);
    }

    [Fact]
    public async Task Handle_UserMissing_ReturnsNotFound()
    {
        var command = new CreateTrackCommand(404, "Orphan Song", Guid.NewGuid(), Guid.NewGuid());

        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);

        Assert.Equal(ErrorType.NotFound, result.FirstError.Type);
    }

    [Fact]
    public async Task Handle_PictureIntentBelongsToAnotherUser_ReturnsError()
    {
        var user = TestEntities.User(1, "user");
        var otherUser = TestEntities.User(2, "other");
        var (picture, audio) = SeedIntents(otherUser.Id);
        await SeedAsync(user, otherUser, picture, audio);

        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id);

        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);

        Assert.True(result.IsError);
        await eventBus.DidNotReceive().PublishAsync(Arg.Any<Musify.Application.Events.CreateTrackResourcesEvent>(), Arg.Any<CancellationToken>());
    }

    [Fact]
    public async Task Handle_AudioIntentAlreadyConsumed_ReturnsError()
    {
        var user = TestEntities.User();
        var picture = TestEntities.UploadIntent(user.Id, UploadIntentPurpose.TrackPicture, objectName: "cover.webp");
        var audio = TestEntities.UploadIntent(user.Id, UploadIntentPurpose.TrackAudio, objectName: "song.mp3", status: UploadIntentStatus.Consumed);
        await SeedAsync(user, picture, audio);

        var command = new CreateTrackCommand(user.Id, "My Song", picture.Id, audio.Id);

        var result = await CreateHandler().Handle(command, TestContext.Current.CancellationToken);

        Assert.Equal(ErrorType.Conflict, result.FirstError.Type);
    }
}