fable/val Public Public: anyone can read this; nobody can change it.

import { describe, expect, test } from "bun:test";

import { choosePrompt } from "../static/prompt.js";

type Snap = ReturnType<typeof snapshot>;

const snapshot = (over: Record<string, unknown> = {}, me: Record<string, unknown> = {}, spike: Record<string, unknown> = {}) => ({

  phase: "live",

  clock: 40,

  result: null,

  me: { side: "atk", alive: true, blind: 0, planting: 0, spike: false, ...me },

  spike: { planted: false, carried: false, fuse: 0, defuse: 0, x: 100, y: 100, ...spike },

  ...over,

});

describe("the one prompt on screen", () => {

  test("the buy phase says what to do, which side you are on, and how long there is", () => {

    const text = choosePrompt(snapshot({ phase: "buy", clock: 14.2 }));

    expect(text).toBe("Buy phase — 15s left. You attack: plant the spike on A or B. Click a gun you can afford.");

    expect(choosePrompt(snapshot({ phase: "buy", clock: 14.2 }, { side: "def" }))).toContain("You defend: hold A and B.");

  });

  test("the terminal is told about keys, not clicks", () => {

    const text = choosePrompt(snapshot({ phase: "buy", clock: 14.2 }), { input: "keys" });

    expect(text).toContain("Press b and buy a gun you can afford.");

  });

  test("carrying the spike off a site sends you to one", () => {

    expect(choosePrompt(snapshot({}, { spike: true }), { onSite: false })).toBe(

      "You have the spike — get to site A or B",

    );

  });

  test("carrying it onto a site says how to plant", () => {

    expect(choosePrompt(snapshot({}, { spike: true }), { onSite: true })).toBe("Hold F to plant");

  });

  test("a defender near a planted spike is told to defuse, with the fuse", () => {

    const text = choosePrompt(snapshot({}, { side: "def" }, { planted: true, fuse: 31.4 }), { nearSpike: true });

    expect(text).toBe("Spike down, 32s — hold F to defuse");

  });

  test("a defender across the map is told to get to it", () => {

    const text = choosePrompt(snapshot({}, { side: "def" }, { planted: true, fuse: 31.4 }), { nearSpike: false });

    expect(text).toBe("Spike down, 32s — get to it and hold F");

  });

  test("an attacker with it planted is told to hold the site", () => {

    expect(choosePrompt(snapshot({}, {}, { planted: true, fuse: 10 }))).toBe(

      "Spike down, 10s — keep them off it",

    );

  });

  test("blind beats everything else on screen", () => {

    const text = choosePrompt(snapshot({}, { blind: 1.4, spike: true }), { onSite: true });

    expect(text).toBe("You are blind — back off until it clears");

  });

  test("dead in a live round says you are still in the match", () => {

    expect(choosePrompt(snapshot({}, { alive: false }))).toBe("Waiting for the next round — you're in it");

  });

  test("the end of a round says whether you won, why, and the countdown", () => {

    // The server's `result` is only ever set when the MATCH is over; the round's

    // outcome travels as `last`. The old test fed a snapshot the server never

    // sends, and the real one read "Round over" and nothing else.

    const last = { round: 3, winner: "blue", why: "Spike defused" };

    const lost = choosePrompt(snapshot({ phase: "end", clock: 4.1, last }, { team: "red" }));

    expect(lost).toBe("Round lost — spike defused · next round in 5s");

    const won = choosePrompt(snapshot({ phase: "end", clock: 4.1, last }, { team: "blue" }));

    expect(won).toBe("Round won — spike defused · next round in 5s");

    // Dead or alive, the outcome is the thing to say at that moment.

    expect(choosePrompt(snapshot({ phase: "end", clock: 4.1, last }, { team: "red", alive: false }))).toBe(lost);

    expect(choosePrompt(snapshot({ phase: "end", clock: 4.1, last: null }))).toBe("Round over · next round in 5s");

  });

  test("the end of the match names the winner and says a new one is coming", () => {

    const text = choosePrompt(snapshot({ phase: "over", clock: 11.2, result: "red win 13–7" }));

    expect(text).toBe("Match over — red win 13–7 · a new match starts in 12s");

  });

  test("a live defender is told what defending is", () => {

    expect(choosePrompt(snapshot({}, { side: "def" }))).toBe("Defending — hold A and B, 40s");

  });

  test("an attacker beside a loose spike is told to walk onto it", () => {

    expect(choosePrompt(snapshot(), { nearSpike: true })).toBe("Walk onto the spike to pick it up");

  });

  test("defusing counts down the defuse, not the fuse", () => {

    const text = choosePrompt(snapshot({}, { side: "def" }, { planted: true, fuse: 20, defuse: 3.5 }), {

      nearSpike: true,

    });

    expect(text).toBe("Defusing — keep holding F, 4s");

  });

  test("no snapshot yet is no prompt", () => {

    expect(choosePrompt(null as unknown as Snap)).toBe("");

  });

});