ersatztv/ErsatzTV.Tests/Application/MediaCollections/MultiCollectionConcurrencyTests.cs

using System.Threading.Channels;
using ErsatzTV.Application;
using ErsatzTV.Application.MediaCollections;
using ErsatzTV.Core;
using ErsatzTV.Core.Domain;
using ErsatzTV.Core.Errors;
using ErsatzTV.Core.Interfaces.Repositories;
using ErsatzTV.Infrastructure.Data;
using ErsatzTV.Tests.Support;
using LanguageExt;
using Microsoft.EntityFrameworkCore;
using NSubstitute;
using NUnit.Framework;
using Shouldly;
using Unit = LanguageExt.Unit;
using static LanguageExt.Prelude;

namespace ErsatzTV.Tests.Application.MediaCollections;

/// <summary>
///     #253 optimistic-concurrency contract on the MultiCollection replace handler (#9): pre-check 412
///     (standalone Either, not flattened to 422), the unconditional Version bump, and the M2 rework of
///     the old <c>SaveChangesAsync() &gt; 0</c> gate — a name-only change still saves (and bumps) but must
///     NOT rebuild playouts, since the version bump rides the first (name) save while the item save stays
///     gated on real item changes.
/// </summary>
[TestFixture]
public class MultiCollectionConcurrencyTests : MediaCollectionHandlerTestBase
{
    private static UpdateMultiCollection Update(int id, string name, Option<int> expectedVersion) =>
        new(id, name, [], expectedVersion.Map(v => new[] { v }.ToSeq()));

    private async Task SeedMultiCollection(int id, int version, string name = "Multi")
    {
        await using TvContext context = Db.CreateContext();
        context.MultiCollections.Add(new MultiCollection
        {
            Id = id,
            Name = name,
            Version = version,
            MultiCollectionItems = [],
            MultiCollectionSmartItems = []
        });
        await context.SaveChangesAsync();
    }

    private async Task<int> ReadVersion(int id)
    {
        await using TvContext context = Db.CreateContext();
        return await context.MultiCollections.Where(c => c.Id == id).Select(c => c.Version).SingleAsync();
    }

    private UpdateMultiCollectionHandler MakeHandler(IMediaCollectionRepository repo) =>
        new(Db.Factory, repo, Worker, SearchTargets);

    private static IMediaCollectionRepository EmptyRepo()
    {
        IMediaCollectionRepository repo = Substitute.For<IMediaCollectionRepository>();
        repo.PlayoutIdsUsingMultiCollection(Arg.Any<int>()).Returns([]);
        return repo;
    }

    private static BaseError LeftOf(Either<BaseError, Unit> either) =>
        either.Match(Left: e => e, Right: _ => throw new AssertionException("Expected a Left result"));

    [Test]
    public async Task Update_Stale_If_Match_Should_Fail_Precondition_And_Not_Mutate()
    {
        await SeedMultiCollection(1, version: 2);

        Either<BaseError, Unit> result =
            await MakeHandler(EmptyRepo()).Handle(Update(1, "Renamed", Some(1)), CancellationToken.None);

        LeftOf(result).ShouldBeOfType<PreconditionFailedError>();
        (await ReadVersion(1)).ShouldBe(2);
    }

    [Test]
    public async Task Update_Matching_If_Match_Should_Succeed_And_Bump()
    {
        await SeedMultiCollection(1, version: 2);

        Either<BaseError, Unit> result =
            await MakeHandler(EmptyRepo()).Handle(Update(1, "Renamed", Some(2)), CancellationToken.None);

        result.IsRight.ShouldBeTrue();
        (await ReadVersion(1)).ShouldBe(3);
    }

    [Test]
    public async Task Name_Only_Change_Should_Bump_But_Not_Rebuild_Playouts()
    {
        await SeedMultiCollection(1, version: 1, name: "Before");
        IMediaCollectionRepository repo = EmptyRepo();

        Either<BaseError, Unit> result =
            await MakeHandler(repo).Handle(Update(1, "After", None), CancellationToken.None);

        result.IsRight.ShouldBeTrue();
        (await ReadVersion(1)).ShouldBe(2);

        // M2: the version bump rides the first (name) save, so the second (items) save writes nothing →
        // no rebuild is enqueued and the search index is not signalled for a name-only edit.
        SearchTargets.DidNotReceive().SearchTargetsChanged();
        await repo.DidNotReceive().PlayoutIdsUsingMultiCollection(Arg.Any<int>());
    }
}