OneAbove.Arena.GameContract.Testing 6.5.0

OneAbove.Arena.GameContract.Testing

The check every rule module of the One-Above Arena has to pass.

It is no recommendation: the platform takes on no module version whose suite has not run green. It stands in place of the code review that does not exist between the repos.

Use

Inherit, fill one member, done:

using OneAbove.Arena.GameContract.Testing;

public sealed class MyGameContractTests
    : GameEngineContract<MyState, MyMove, MyView>
{
    protected override IGameEngine<MyState, MyMove, MyView> Engine { get; }
        = new MyGame();
}

That checks purity, determinism, the serialisation round trip, totality, leaks and the end of the match — and plays a few moves by itself in the process, so that not only the initial state is checked.

The suite derives its arrangements from your descriptor: every mode you carry (online, hot seat, solo), every declared seat count, and every option sampled one at a time. You cannot narrow it; you can only declare less — and that stands out.

Since contract 6.1 every (mode, option, value) is sampled uncapped, at the first seat count where the option and its ancestors apply, with the path of parents set that makes it visible (GameDescriptor.OptionSamples()). Two checks hold the sampler itself: every sample must be accepted by MatchSetup.Problems and show its option, and every declared value must have been sampled. The bound is in the descriptor: more than 128 samples and Problems() refuses it. ⚠️ Until 6.0 the list was cut at 24 arrangements — if your own tests pinned that number, they change.

PlayDepth says how many moves deep it plays. The default is 12; override it when a game needs more or fewer.

⚠️ What you have to say: what is hidden

Since contract 4.0 that stands in the rule module, no longer in the test project.

Two statements, and they have to match one another:

1. In the descriptor, for every game:

OpenInformation = true,   // chess, Vier gewinnt: everyone sees everything

2. On the module, when OpenInformation = false:

public sealed class MyGame
    : IGameEngine<MyState, MyMove, MyView>, ISecretDeclaration<MyState>
{
    public IReadOnlyList<string> SecretsFor(MyState state, Seat? seat) =>
        seat is Seat owner
            ? [.. state.Hands[owner.Index].Select(card => card.Id)]
            : [.. state.DrawPile.Select(card => card.Id)];
}

The suite then checks that none of these strings occurs in a foreign view.

⚠️ Seat?, not Seat — and null is the interesting case. It means „nobody may see this": the unshuffled draw pile, Minesweeper's mines, a hidden solution. Whoever attributes such a thing to a seat is claiming that this seat may see it — and then precisely that seat's view is not checked.

Why this moved

Your rule module runs in the arena in a container of its own. The platform checks a new release over a socket — there it has neither your state type nor your test project. A check running only at your place is none.

Concretely the migration reads: your secrets method moves out of rules.tests into rules, is called SecretsFor and takes a Seat? instead of a Seat. The old overridable hook is gone — OpenInformation in the descriptor now says it.

For a game with completely open information you do not need the interface. There the canary bites: the match's seed may stand in no view.

Your open view (contract 6.4)

⚠️ Built in the platform's repo, not yet published — the chain rc → template → number waits for the product owner.

If your module implements IRevealedView<TState, TView>, four checks look at it — and none of them runs the leak checks over it, because showing the hands after the end is its point:

And No_view_reveals_the_seed now looks into the open view too: it may show every hand, never the seed.

A game without the interface passes the four trivially — it simply gets no switch in the arena's replay.

Golden matches

Recorded matches, replayed bit-identically. The only defence against a change nobody took for a rule change.

GoldenGameRunner.Verify(GoldenGameFile.Load("2026-09-06-first-match.json"), engine);

When a golden test goes red, the first question is not „what is wrong with the recording" but: did we just change the rules?

• Deliberately ⇒ raise GameVersion and create a new recording. The old one stays and has to remain green under its old version — it is the proof that running matches stay replayable.
• Unintentionally ⇒ you have just found a bug.

Your media (contract 4.4)

If your repo has a media/ directory, the suite runs the platform's own check over it — the same method the admission runs, out of the contract package. So a refused manual costs you a test run and not a v tag, which is the one step you cannot take back.

Since contract 6.2 that includes the pictures themselves: bytes that match the extension, a readable header, at most 4096 × 4096 — and, for a screenshot your manual's Overview shows, no EXIF or XMP. A cover exported with its editor's metadata still passes; the same file as an overview screenshot does not.

It looks for media/ by walking up from the test assembly, because that is the only way to reach it: a test runs in bin/<config>/<tfm>/, the media lie at your repo root beside golden/ and renderer/. The path is the same one game-publish.yml copies into your image — override MediaDirectory only if you move it in both, because otherwise „the suite found nothing" and „the image ships nothing" become two states instead of one.

⚠️ No media is a pass, and it passes silently. A game does not have to bring any, and xUnit 2.9 shows no message for a passing test. So if you expected your cover to be checked and nothing happened, the directory is not where the suite looked — and it is not where the pipeline will look either.

What this suite does not check

Your game's rules. That a rook does not move diagonally is noticed by nobody here. That is what your own tests are for.