Testing Standards: Coverage, Structure, and CI Rules

[TestFixture]
public sealed class SetValidatorTests
{
    private SetValidator _validator;

    [SetUp]
    public void SetUp()
    {
        _validator = new SetValidator();
    }

    [Test]
    public void Validate_AllAttributesDifferent_ReturnsValid()
    {
        // Arrange
        var cards = new[]
        {
            CardFactory.Create(Number.One,   Shape.Diamond,  Color.Red,    Shading.Solid),
            CardFactory.Create(Number.Two,   Shape.Squiggle, Color.Green,  Shading.Striped),
            CardFactory.Create(Number.Three, Shape.Oval,     Color.Purple, Shading.Open),
        };

        // Act
        SetResult result = _validator.Validate(cards);

        // Assert
        Assert.IsTrue(result.IsValid);
        Assert.IsNull(result.Reason);
    }

    [Test]
    public void Validate_TwoCardsSameNumberOneDifferent_ReturnsInvalid()
    {
        // Arrange
        var cards = new[]
        {
            CardFactory.Create(Number.One,  Shape.Diamond,  Color.Red,    Shading.Solid),
            CardFactory.Create(Number.One,  Shape.Squiggle, Color.Green,  Shading.Striped),
            CardFactory.Create(Number.Two,  Shape.Oval,     Color.Purple, Shading.Open),
        };

        // Act
        SetResult result = _validator.Validate(cards);

        // Assert
        Assert.IsFalse(result.IsValid);
        Assert.AreEqual(InvalidReason.Number, result.Reason);
    }
}

[TestFixture]
public sealed class GameSessionTests
{
    private ISetValidator _mockValidator;
    private IAIScanner _mockScanner;
    private GameSession _session;

    [SetUp]
    public void SetUp()
    {
        _mockValidator = Substitute.For<ISetValidator>();
        _mockScanner   = Substitute.For<IAIScanner>();
        _session       = new GameSession(_mockValidator, _mockScanner);
    }

    [Test]
    public void HandleCommand_ClaimValidSet_EmitsSetClaimedEvent()
    {
        // Arrange
        _mockValidator
            .Validate(Arg.Any<IReadOnlyList<Card>>())
            .Returns(new SetResult(isValid: true, reason: null));

        MatchEvent capturedEvent = null;
        _session.EventStream.Subscribe(e => capturedEvent = e);

        _session.StartMatch(GameRules.Default);
        SelectThreeCards(_session, 0, 1, 2);

        // Act
        _session.HandleCommand(new ClaimSelectedCommand(PlayerId.Local));

        // Assert
        Assert.IsNotNull(capturedEvent);
        Assert.IsInstanceOf<SetClaimedEvent>(capturedEvent);
    }

    [Test]
    public void HandleCommand_ClaimInvalidSet_AppliesPointPenalty()
    {
        // Arrange
        _mockValidator
            .Validate(Arg.Any<IReadOnlyList<Card>>())
            .Returns(new SetResult(isValid: false, reason: InvalidReason.Color));

        var rules = new GameRules(penaltyMode: PenaltyMode.Point, pointPenalty: 1);
        _session.StartMatch(rules);
        SelectThreeCards(_session, 0, 1, 2);

        // Act
        _session.HandleCommand(new ClaimSelectedCommand(PlayerId.Local));
        GameStateSnapshot snapshot = _session.CurrentSnapshot;

        // Assert
        Assert.AreEqual(-1, snapshot.Players[0].Score);
    }

    private static void SelectThreeCards(GameSession session, params int[] slots)
    {
        foreach (int slot in slots)
        {
            session.HandleCommand(new SelectCardCommand(slot));
        }
    }
}

MethodName_Scenario_ExpectedBehavior

[Test]
public void FindAllSets_FullBoard_ReturnsAtLeastOneSet()
{
    // Arrange
    var board = BoardFactory.CreateBoardWithKnownSet();
    var validator = new SetValidator();

    // Act
    IReadOnlyList<SetTriple> sets = validator.FindAllSets(board.Cards);

    // Assert
    Assert.Greater(sets.Count, 0);
}

For each of the 4 attributes (Number, Shape, Color, Shading):
  ✅ All-same (valid)
  ✅ All-different (valid)
  ❌ Two-same, one-different (invalid — name the violated attribute in the Reason)

Mixed valid set:
  ✅ Some attributes all-same, others all-different

FindAllSets:
  ✅ Board with 1 known Set returns that Set
  ✅ Board with 0 Sets returns empty list
  ✅ Board with multiple overlapping Sets returns all of them

AnySetExists:
  ✅ Returns true when at least one valid Set exists
  ✅ Returns false on a board constructed to have no valid Set

✅ Placing a card on an occupied slot throws ArgumentException (or returns a Result failure)
✅ Board expands by 3 slots when AnySetExists() is false and deck has cards remaining
✅ Board does not expand beyond MaxBoardSize (21)
✅ Removing 3 cards from a claimed Set correctly vacates those slots

For every valid transition:
  ✅ Command is accepted and state advances correctly
  ✅ Correct MatchEvent is emitted

For every invalid transition:
  ✅ Command is silently discarded
  ✅ State does not change
  ✅ No event emitted

Penalty logic:
  ✅ PenaltyMode.None — no score change on invalid claim
  ✅ PenaltyMode.Point — configurable point deduction applied
  ✅ PenaltyMode.Time — configurable time penalty applied

End-game conditions:
  ✅ Deck empty + no valid Set on board → MatchEnd event
  ✅ Timer expires (timed mode) → MatchEnd event
  ✅ All opponents disconnect (multiplayer) → MatchEnd event

✅ AI reaction time falls within configured min/max delay window over 100 rounds
✅ AI miss rate matches configured value ± 5% over 1 000 rounds
✅ AI cancels pending claim when board changes

// Application layer interface
public interface ITimeProvider
{
    float ElapsedSeconds { get; }
}

// In tests — fully controlled
public sealed class FakeTimeProvider : ITimeProvider
{
    public float ElapsedSeconds { get; set; }
}

[Test]
public void GameSession_TimerExpires_EmitsMatchEndEvent()
{
    var time = new FakeTimeProvider { ElapsedSeconds = 0f };
    var session = new GameSession(_mockValidator, _mockScanner, time);
    session.StartMatch(new GameRules(timeLimitSeconds: 60f));

    MatchEvent lastEvent = null;
    session.EventStream.Subscribe(e => lastEvent = e);

    time.ElapsedSeconds = 61f;
    session.Tick(); // Application-layer tick, not Unity Update

    Assert.IsInstanceOf<MatchEndEvent>(lastEvent);
}