PkmnLib.NET/Plugins/PkmnLib.Plugin.Gen7.Tests/Scripts/Moves/MatBlockTests.cs

using PkmnLib.Dynamic.Models;
using PkmnLib.Dynamic.ScriptHandling;
using PkmnLib.Dynamic.ScriptHandling.Registry;
using PkmnLib.Plugin.Gen7.Scripts.Moves;
using PkmnLib.Plugin.Gen7.Scripts.Side;
using PkmnLib.Static.Moves;

namespace PkmnLib.Plugin.Gen7.Tests.Scripts.Moves;

/// <summary>
/// Tests for the <see cref="MatBlock"/> move script and the <see cref="MatBlockEffect"/> it applies.
/// Gen VII Bulbapedia behavior: "Mat Block protects all Pokémon on the user's side of the field from any
/// physical or special moves for that turn."
/// </summary>
public class MatBlockTests
{
    private static (MatBlock script, IExecutingMove move, IPokemon target, IHitData hitData, IScriptSet sideVolatile)
        CreateTestSetup(uint switchInTurn, uint currentTurn)
    {
        var script = new MatBlock();

        var side = Substitute.For<IBattleSide>();
        // Use a real script set so the side script added by Mat Block can be inspected afterwards.
        var sideVolatile = new ScriptSet(side);
        side.VolatileScripts.Returns(sideVolatile);
        side.GetScripts().Returns(_ => new ScriptIterator(new List<IEnumerable<ScriptContainer>>()));

        var battle = Substitute.For<IBattle>();
        battle.CurrentTurnNumber.Returns(currentTurn);

        var battleData = Substitute.For<IPokemonBattleData>();
        battleData.Battle.Returns(battle);
        battleData.BattleSide.Returns(side);
        battleData.SwitchInTurn.Returns(switchInTurn);

        var user = Substitute.For<IPokemon>();
        user.BattleData.Returns(battleData);
        var move = Substitute.For<IExecutingMove>();
        move.User.Returns(user);

        var target = Substitute.For<IPokemon>();
        var hitData = Substitute.For<IHitData>();
        move.GetHitData(target, 0).Returns(hitData);

        return (script, move, target, hitData, sideVolatile);
    }

    private static IExecutingMove CreateExecutingMoveOfCategory(MoveCategory category)
    {
        var useMove = Substitute.For<IMoveData>();
        useMove.Category.Returns(category);
        var move = Substitute.For<IExecutingMove>();
        move.UseMove.Returns(useMove);
        return move;
    }

    /// <summary>
    /// Bulbapedia: "Mat Block protects all Pokémon on the user's side of the field" — using the move on
    /// the user's first turn on the field attaches the <see cref="MatBlockEffect"/> to the user's side.
    /// </summary>
    [Test]
    public async Task OnSecondaryEffect_UsedOnSwitchInTurn_AddsMatBlockEffectToUsersSide()
    {
        // Arrange
        var (script, move, target, _, sideVolatile) = CreateTestSetup(1, 1);

        // Act
        script.OnSecondaryEffect(move, target, 0);

        // Assert
        await Assert.That(sideVolatile.Contains(ScriptUtils.ResolveName<MatBlockEffect>())).IsTrue();
    }

    /// <summary>
    /// Bulbapedia: Mat Block only fails "if not used on the first turn after the Pokémon enters the
    /// field" — on the user's first turn on the field the hit is not marked as failed.
    /// </summary>
    [Test]
    public async Task OnSecondaryEffect_UsedOnSwitchInTurn_HitDoesNotFail()
    {
        // Arrange
        var (script, move, target, hitData, _) = CreateTestSetup(1, 1);

        // Act
        script.OnSecondaryEffect(move, target, 0);

        // Assert
        await Assert.That(hitData.ReceivedCalls().Any(c => c.GetMethodInfo().Name == "Fail")).IsFalse();
    }

    /// <summary>
    /// Bulbapedia: "Mat Block will fail if not used on the first turn after the Pokémon enters the field;
    /// the Pokémon must be switched out and back in to be able to use Mat Block again."
    /// </summary>
    [Test]
    public async Task OnSecondaryEffect_NotFirstTurnOnField_HitFails()
    {
        // Arrange
        var (script, move, target, hitData, _) = CreateTestSetup(1, 2);

        // Act
        script.OnSecondaryEffect(move, target, 0);

        // Assert
        await Assert.That(hitData.ReceivedCalls().Any(c => c.GetMethodInfo().Name == "Fail")).IsTrue();
    }

    /// <summary>
    /// Bulbapedia: "Mat Block will fail if not used on the first turn after the Pokémon enters the field"
    /// — when it fails, no protection is set up on the user's side.
    /// </summary>
    [Test]
    public async Task OnSecondaryEffect_NotFirstTurnOnField_NoEffectAdded()
    {
        // Arrange
        var (script, move, target, _, sideVolatile) = CreateTestSetup(1, 2);

        // Act
        script.OnSecondaryEffect(move, target, 0);

        // Assert
        await Assert.That(sideVolatile.Contains(ScriptUtils.ResolveName<MatBlockEffect>())).IsFalse();
    }

    /// <summary>
    /// Bulbapedia: the protection covers "any physical or special moves" — the
    /// <see cref="MatBlockEffect"/> blocks an incoming damaging hit of either category.
    /// </summary>
    [Test, Arguments(MoveCategory.Physical), Arguments(MoveCategory.Special)]
    public async Task MatBlockEffect_DamagingMove_IsBlocked(MoveCategory category)
    {
        // Arrange
        var effect = new MatBlockEffect();
        var incomingMove = CreateExecutingMoveOfCategory(category);
        var block = false;

        // Act
        effect.BlockIncomingHit(incomingMove, Substitute.For<IPokemon>(), 0, ref block);

        // Assert
        await Assert.That(block).IsTrue();
    }

    /// <summary>
    /// Bulbapedia: Mat Block protects "from any physical or special moves" — unlike Protect it does not
    /// stop status moves, so an incoming status move is not blocked.
    /// </summary>
    [Test]
    public async Task MatBlockEffect_StatusMove_IsNotBlocked()
    {
        // Arrange
        var effect = new MatBlockEffect();
        var incomingMove = CreateExecutingMoveOfCategory(MoveCategory.Status);
        var block = false;

        // Act
        effect.BlockIncomingHit(incomingMove, Substitute.For<IPokemon>(), 0, ref block);

        // Assert
        await Assert.That(block).IsFalse();
    }

    /// <summary>
    /// Bulbapedia: the protection lasts "for that turn" — at the end of the turn the
    /// <see cref="MatBlockEffect"/> removes itself from the side.
    /// </summary>
    [Test]
    public async Task MatBlockEffect_OnEndTurn_EffectExpires()
    {
        // Arrange
        var effect = new MatBlockEffect();
        var side = Substitute.For<IBattleSide>();
        side.GetScripts().Returns(_ => new ScriptIterator(new List<IEnumerable<ScriptContainer>>()));
        IScriptSet sideVolatile = new ScriptSet(side);
        sideVolatile.Add(effect);

        // Act
        effect.OnEndTurn(side, Substitute.For<IBattle>());

        // Assert
        await Assert.That(sideVolatile.Contains(ScriptUtils.ResolveName<MatBlockEffect>())).IsFalse();
    }

    /// <summary>
    /// Technical test: outside of battle (no battle data) no protection can be raised and nothing
    /// happens.
    /// </summary>
    [Test]
    public async Task OnSecondaryEffect_NullBattleData_DoesNothing()
    {
        // Arrange
        var (script, move, target, hitData, sideVolatile) = CreateTestSetup(1, 1);
        move.User.BattleData.Returns((IPokemonBattleData?)null);

        // Act
        script.OnSecondaryEffect(move, target, 0);

        // Assert - no effect is added and the hit is not failed
        await Assert.That(sideVolatile.Contains(ScriptUtils.ResolveName<MatBlockEffect>())).IsFalse();
        await Assert.That(hitData.ReceivedCalls().Any(c => c.GetMethodInfo().Name == "Fail")).IsFalse();
    }
}