ersatztv/ErsatzTV.Tests/Application/Playouts/BuildPlayoutHandlerTests.cs

using System.Threading.Channels;
using ErsatzTV.Application;
using ErsatzTV.Application.Playouts;
using ErsatzTV.Core;
using ErsatzTV.Core.Interfaces.FFmpeg;
using ErsatzTV.Core.Interfaces.Locking;
using ErsatzTV.Core.Interfaces.Scheduling;
using ErsatzTV.Core.Scheduling;
using ErsatzTV.Tests.Support;
using LanguageExt;
using Microsoft.Extensions.Logging.Abstractions;
using NSubstitute;
using NUnit.Framework;
using Shouldly;
using Channel = System.Threading.Channels.Channel;
using Unit = LanguageExt.Unit;

namespace ErsatzTV.Tests.Application.Playouts;

[TestFixture]
public class BuildPlayoutHandlerTests
{
    private InMemoryTvContext _db = null!;
    private ChannelWriter<IBackgroundServiceRequest> _worker = null!;
    private IEntityLocker _entityLocker = null!;
    private IPlayoutTimeShifter _timeShifter = null!;

    [SetUp]
    public async Task SetUp()
    {
        _db = await InMemoryTvContext.CreateAsync();
        _worker = Channel.CreateUnbounded<IBackgroundServiceRequest>().Writer;
        _entityLocker = Substitute.For<IEntityLocker>();
        _timeShifter = Substitute.For<IPlayoutTimeShifter>();
    }

    [TearDown]
    public async Task TearDown() => await _db.DisposeAsync();

    private BuildPlayoutHandler CreateHandler() =>
        new(
            _db.Factory,
            Substitute.For<IPlayoutBuilder>(),
            Substitute.For<IBlockPlayoutBuilder>(),
            Substitute.For<IBlockPlayoutFillerBuilder>(),
            Substitute.For<ISequentialPlayoutBuilder>(),
            Substitute.For<IScriptedPlayoutBuilder>(),
            Substitute.For<IExternalJsonPlayoutBuilder>(),
            Substitute.For<IFFmpegSegmenterService>(),
            _entityLocker,
            _timeShifter,
            _worker,
            NullLogger<BuildPlayoutHandler>.Instance);

    [Test]
    public async Task Build_Should_Skip_And_Not_Cross_Release_When_Playout_Already_Locked()
    {
        // another operation (a concurrent build or the subtitle extractor) already holds the lock
        _entityLocker.LockPlayout(5).Returns(false);
        BuildPlayoutHandler handler = CreateHandler();

        Either<BaseError, Unit> result =
            await handler.Handle(new BuildPlayout(5, PlayoutBuildMode.Continue), CancellationToken.None);

        // skipped cleanly (no error surfaced to the caller)
        result.IsRight.ShouldBeTrue();

        // did not proceed to build the playout...
        await _timeShifter.DidNotReceive()
            .TimeShift(Arg.Any<int>(), Arg.Any<DateTimeOffset>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());

        // ...and crucially did not release the other owner's lock (no cross-release)
        await _entityLocker.DidNotReceive().UnlockPlayout(5);
    }

    [Test]
    public async Task Build_Should_Release_Lock_When_Owned_Even_If_Validation_Fails()
    {
        // this caller wins the lock
        _entityLocker.LockPlayout(999).Returns(true);
        BuildPlayoutHandler handler = CreateHandler();

        // playout 999 does not exist -> validation fails -> Left, but the finally must still release
        Either<BaseError, Unit> result =
            await handler.Handle(new BuildPlayout(999, PlayoutBuildMode.Reset), CancellationToken.None);

        result.IsLeft.ShouldBeTrue();
        await _entityLocker.Received(1).UnlockPlayout(999);
    }
}