Pierre MARTINandClaude Opus 5.5
0bb41524bf
Reproduit le défaut signalé : après une partie finie, l'application rouverte, « Commencer » de l'écran « Nouvelle partie » ramenait au bilan de l'ancienne partie. Vérifie l'accueil, le menu et « Changer les réglages ». Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
322 lines
12 KiB
JavaScript
322 lines
12 KiB
JavaScript
// nouvelle-partie.mjs -- après une partie finie et son bilan, « Nouvelle
|
||
// partie » mène tout droit à la nouvelle partie, sur le plateau, avec les
|
||
// réglages choisis, par chaque entrée vers #/nouvelle-partie : l'accueil
|
||
// (l'application rouverte), le menu, « Changer les réglages » du bilan.
|
||
// Dans un vrai navigateur sans écran (Playwright), sur le site servi par
|
||
// l'image de production.
|
||
//
|
||
// Copyright (C) 2026 les auteurs d'Ustagammon.
|
||
// Licence : GPLv3 ou ultérieure (voir LICENSE).
|
||
//
|
||
// Usage : node nouvelle-partie.mjs <adresse du site> <chromium|firefox> <dossier des captures>
|
||
// Lancé par tests/browser.sh. Défaut signalé par un joueur : « tu fais
|
||
// nouvelle partie […] tu te retrouves sur le résultat du match précédent et
|
||
// tu dois cliquer à nouveau sur nouvelle partie ». Chaque partie finie est
|
||
// une fin de course courte, partie d'un lien de position avec des dés
|
||
// imposés, comme dans bilan.mjs. Vérifie aussi le libellé du bouton
|
||
// (« Commencer la partie », « Commencer le match ») et que le coup de
|
||
// l'ordinateur, sur la ligne d'information, mène à la fiche « Notation des
|
||
// coups ». Captures (Chromium) dans <dossier des captures>/nouvelle-partie/,
|
||
// en 412×915 et 915×412.
|
||
|
||
import { mkdirSync } from "node:fs";
|
||
import { chromium, firefox } from "playwright";
|
||
import { hiddenUnderActionBar } from "./recette.mjs";
|
||
|
||
const [base, browserName, shots] = process.argv.slice(2);
|
||
const browserType = { chromium, firefox }[browserName];
|
||
if (!base || !browserType || !shots) {
|
||
console.error("usage : node nouvelle-partie.mjs <adresse> <chromium|firefox> <dossier des captures>");
|
||
process.exit(2);
|
||
}
|
||
const full = browserName === "chromium";
|
||
const dir = `${shots}/nouvelle-partie`;
|
||
mkdirSync(dir, { recursive: true });
|
||
const PORTRAIT = { width: 412, height: 915 };
|
||
const LANDSCAPE = { width: 915, height: 412 };
|
||
// Le joueur au trait : un pion sur 6, un sur 1 ; l'ordinateur : un sur 1,
|
||
// un sur 2. Le joueur joue 6/5/off, l'ordinateur double, le joueur passe.
|
||
const BEAROFF = "BQAACAIAAAAAAA";
|
||
|
||
const problems = [];
|
||
const log = (text) => console.log(`[${browserName}] ${text}`);
|
||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
||
let captures = 0;
|
||
|
||
function check(condition, message) {
|
||
if (!condition) {
|
||
throw new Error(message);
|
||
}
|
||
}
|
||
|
||
const browser = await browserType.launch();
|
||
const context = await browser.newContext({
|
||
viewport: PORTRAIT,
|
||
deviceScaleFactor: 1,
|
||
locale: "fr-FR",
|
||
reducedMotion: "reduce",
|
||
});
|
||
await context.addInitScript(() => {
|
||
// Les dés imposés d'abord (un dé par valeur), puis une graine fixe.
|
||
window.__dice = [];
|
||
let state = 7;
|
||
Math.random = () => {
|
||
const die = window.__dice.shift();
|
||
if (die !== undefined) {
|
||
return (die - 0.5) / 6;
|
||
}
|
||
state = (state * 1103515245 + 12345) % 2147483648;
|
||
return state / 2147483648;
|
||
};
|
||
window.__csp = [];
|
||
document.addEventListener("securitypolicyviolation", (e) =>
|
||
window.__csp.push(`${e.effectiveDirective} ${e.blockedURI}`),
|
||
);
|
||
});
|
||
const page = await context.newPage();
|
||
page.on("pageerror", (error) => problems.push(`erreur de la page : ${error.message}`));
|
||
page.on("console", (message) => {
|
||
if (message.type() === "error") {
|
||
problems.push(`console : ${message.text()}`);
|
||
}
|
||
});
|
||
|
||
/** Attend une condition dans la page (sans page.waitForFunction, qui passe
|
||
* par eval, interdit par la politique de sécurité du site). */
|
||
async function until(what, fn, arg, ms = 120_000) {
|
||
for (let waited = 0; waited < ms; waited += 100) {
|
||
if (await page.evaluate(fn, arg)) {
|
||
return;
|
||
}
|
||
await sleep(100);
|
||
}
|
||
await page.screenshot({ path: `${dir}/${browserName}-bloque.png` }).catch(() => {});
|
||
throw new Error(`attente trop longue : ${what} (adresse ${await page.evaluate(() => location.hash)})`);
|
||
}
|
||
|
||
const idle = () => until("écran libre", () => !document.body.classList.contains("busy"));
|
||
|
||
/** Une capture en portrait et en paysage (Chromium seulement), après la
|
||
* règle de la recette : rien d'interactif sous une barre d'action. */
|
||
async function capture(name) {
|
||
if (!full) {
|
||
return;
|
||
}
|
||
for (const size of [PORTRAIT, LANDSCAPE]) {
|
||
await page.setViewportSize(size);
|
||
await sleep(300);
|
||
const hidden = await hiddenUnderActionBar(page);
|
||
check(
|
||
hidden.length === 0,
|
||
`${name} ${size.width}x${size.height} : caché sous la barre d'action : ${hidden.join(", ")}`,
|
||
);
|
||
await page.screenshot({ path: `${dir}/${name}-${size.width}x${size.height}.png` });
|
||
captures++;
|
||
}
|
||
await page.setViewportSize(PORTRAIT);
|
||
await sleep(300);
|
||
}
|
||
|
||
/** Une partie finie et son bilan à l'écran : une fin de course depuis un
|
||
* lien de position, 6/5/off, puis le double de l'ordinateur passé. Renvoie
|
||
* l'identifiant de la partie. */
|
||
async function finishedGameWithSummary() {
|
||
await page.goto(`${base}#/position/${encodeURIComponent(BEAROFF)}`);
|
||
await until("position lue", () => {
|
||
const play = document.getElementById("position-play");
|
||
return !play.hidden && !play.disabled;
|
||
});
|
||
await page.click("#position-play");
|
||
await until(
|
||
"partie commencée",
|
||
() =>
|
||
location.hash === "#/" &&
|
||
!document.body.classList.contains("busy") &&
|
||
!document.getElementById("roll").hidden,
|
||
);
|
||
await page.evaluate(() => window.__dice.push(6, 1));
|
||
await page.click("#roll");
|
||
await idle();
|
||
for (const [from, to] of [
|
||
["p6", "p5"],
|
||
["p5", "off-player"],
|
||
]) {
|
||
await page.click(`#board .hit[data-place="${from}"]`);
|
||
await idle();
|
||
const land = page.locator(`#board .hit.can-land[data-place="${to}"]`);
|
||
if ((await land.count()) > 0) {
|
||
await land.click();
|
||
await idle();
|
||
}
|
||
}
|
||
await page.click("#confirm");
|
||
await until("double de l'ordinateur", () => !document.getElementById("drop").hidden);
|
||
await page.click("#drop");
|
||
await until(
|
||
"bilan de la partie finie",
|
||
() =>
|
||
/^#\/parties\/[a-z0-9-]+\/bilan$/.test(location.hash) &&
|
||
document.getElementById("summary")?.dataset.ready === "true",
|
||
);
|
||
return page.evaluate(() => location.hash.split("/")[2]);
|
||
}
|
||
|
||
/** Choisit les réglages sur l'écran « Nouvelle partie », vérifie le libellé
|
||
* du bouton, puis commence. */
|
||
async function chooseAndStart(choice, shot) {
|
||
await until(
|
||
"écran « Nouvelle partie »",
|
||
() =>
|
||
location.hash === "#/nouvelle-partie" &&
|
||
!document.getElementById("new-game").hidden &&
|
||
!document.getElementById("new-game-start").disabled,
|
||
);
|
||
await page.click(choice.match ? "#new-game-match" : "#new-game-free");
|
||
if (choice.match) {
|
||
await page.click(`#new-game-length-${choice.length}`);
|
||
}
|
||
await page.click(`#new-game-level-${choice.level}`);
|
||
const label = await page.textContent("#new-game-start");
|
||
const expected = choice.match ? "Commencer le match" : "Commencer la partie";
|
||
check(label === expected, `bouton : « ${label} », attendu « ${expected} »`);
|
||
if (shot) {
|
||
await capture("1-nouvelle-partie");
|
||
}
|
||
await page.click("#new-game-start");
|
||
}
|
||
|
||
/** La nouvelle partie est à l'écran, sur le plateau, avec les réglages
|
||
* choisis ; ni le bilan ni le panneau de fin de l'ancienne partie, même un
|
||
* peu plus tard. */
|
||
async function checkNewGame(entry, oldId, choice) {
|
||
await until(
|
||
`${entry} : partie commencée`,
|
||
() => location.hash === "#/" && !document.body.classList.contains("busy"),
|
||
);
|
||
// Le défaut apparaissait juste après : l'adresse passait au bilan de
|
||
// l'ancienne partie. On regarde pendant deux secondes.
|
||
for (let waited = 0; waited < 2000; waited += 100) {
|
||
const s = await page.evaluate(() => ({
|
||
hash: location.hash,
|
||
summary: !document.getElementById("summary-veil").hidden,
|
||
panel: !document.getElementById("panel-veil").hidden,
|
||
board: !document.getElementById("game").hidden,
|
||
newGame: !document.getElementById("new-game").hidden,
|
||
}));
|
||
check(
|
||
s.hash === "#/" && !s.summary && !s.panel && s.board && !s.newGame,
|
||
`${entry} : la nouvelle partie n'est pas à l'écran (ancienne partie ${oldId}) : ${JSON.stringify(s)}`,
|
||
);
|
||
await sleep(100);
|
||
}
|
||
await idle();
|
||
const shown = await page.evaluate(() => ({
|
||
line: document.getElementById("match-line").textContent,
|
||
lineShown: !document.getElementById("match-line").hidden,
|
||
level: JSON.parse(localStorage.getItem("ustagammon.settings") ?? "{}").level,
|
||
over: document.getElementById("again").hidden === false,
|
||
}));
|
||
check(!shown.over, `${entry} : la partie à l'écran est finie`);
|
||
check(shown.level === choice.level, `${entry} : niveau ${shown.level}`);
|
||
if (choice.match) {
|
||
check(
|
||
shown.lineShown && shown.line === `Match en ${choice.length} points`,
|
||
`${entry} : ligne du match « ${shown.line} »`,
|
||
);
|
||
} else {
|
||
check(!shown.lineShown, `${entry} : un match au lieu d'une partie libre`);
|
||
}
|
||
log(`${entry} : nouvelle partie directe (${choice.match ? `match en ${choice.length}` : "partie libre"}, ${choice.level})`);
|
||
}
|
||
|
||
// --------------------------- 1. L'application rouverte, puis l'accueil
|
||
|
||
let oldId = await finishedGameWithSummary();
|
||
// L'application rouverte : sans adresse, elle ouvre l'accueil.
|
||
await page.goto(base);
|
||
await until(
|
||
"accueil",
|
||
() =>
|
||
location.hash === "#/accueil" &&
|
||
!document.getElementById("home-new").hidden &&
|
||
!document.getElementById("home-new").disabled,
|
||
);
|
||
await page.click("#home-new");
|
||
let choice = { match: true, length: 3, level: "beginner" };
|
||
await chooseAndStart(choice, true);
|
||
await checkNewGame("accueil", oldId, choice);
|
||
await capture("2-partie-demarree");
|
||
|
||
// Le coup de l'ordinateur, sur la ligne d'information, mène à la fiche
|
||
// « Notation des coups ». On joue jusqu'à ce qu'il ait joué un coup.
|
||
for (let actions = 0; ; actions++) {
|
||
check(actions < 200, "l'ordinateur ne joue pas de coup");
|
||
const link = await page.evaluate(() => document.querySelector("#info a.notation")?.href ?? null);
|
||
if (link !== null) {
|
||
check(link.endsWith("#/glossaire/notation-des-coups"), `lien de la notation : ${link}`);
|
||
break;
|
||
}
|
||
const what = await page.evaluate(() => {
|
||
const usable = (id) => {
|
||
const b = document.getElementById(id);
|
||
return !b.hidden && !b.disabled;
|
||
};
|
||
for (const id of ["take", "skip", "confirm", "roll"]) {
|
||
if (usable(id)) {
|
||
return `#${id}`;
|
||
}
|
||
}
|
||
if (document.querySelector("#board .hit.can-land")) {
|
||
return "#board .hit.can-land";
|
||
}
|
||
return document.querySelector("#board .hit.can-move") ? "#board .hit.can-move" : null;
|
||
});
|
||
if (what === null) {
|
||
await sleep(100);
|
||
continue;
|
||
}
|
||
await page.locator(what).first().click();
|
||
await idle();
|
||
}
|
||
await page.click("#info a.notation");
|
||
await until(
|
||
"fiche « Notation des coups »",
|
||
() =>
|
||
location.hash === "#/glossaire/notation-des-coups" &&
|
||
document.getElementById("glossaire-notation-des-coups") !== null,
|
||
);
|
||
await page.goBack();
|
||
await until("retour à la partie", () => location.hash === "#/");
|
||
log("ligne de l'ordinateur : la notation mène à sa fiche");
|
||
|
||
// --------------------------------- 2. L'application rouverte sur le menu
|
||
|
||
oldId = await finishedGameWithSummary();
|
||
await page.goto(`${base}#/menu`);
|
||
await until("menu", () => !document.getElementById("menu-veil").hidden);
|
||
await page.click("#menu-new-game");
|
||
choice = { match: false, level: "amateur" };
|
||
await chooseAndStart(choice, false);
|
||
await checkNewGame("menu", oldId, choice);
|
||
|
||
// ------------------------------- 3. « Changer les réglages » du bilan
|
||
|
||
oldId = await finishedGameWithSummary();
|
||
await page.click("#summary-settings");
|
||
choice = { match: true, length: 5, level: "intermediate" };
|
||
await chooseAndStart(choice, false);
|
||
await checkNewGame("bilan, « Changer les réglages »", oldId, choice);
|
||
|
||
const csp = await page.evaluate(() => window.__csp);
|
||
for (const violation of csp) {
|
||
problems.push(`politique de sécurité : ${violation}`);
|
||
}
|
||
await browser.close();
|
||
if (problems.length > 0) {
|
||
for (const problem of problems) {
|
||
console.error(`[${browserName}] ${problem}`);
|
||
}
|
||
process.exit(1);
|
||
}
|
||
log(`nouvelle partie : tout est conforme (${captures} captures)`);
|