871 lines
48 KiB
JavaScript
871 lines
48 KiB
JavaScript
|
// © 2026 TechnoLibre (http://www.technolibre.ca)
|
||
|
|
// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
|
||
|
|
|
||
|
|
// Épreuves des commandes du mobilier (§ 4, § 4.3, § 5.9, § 6, § 7.1, § 8.2,
|
||
|
|
// § 9, § 15.4) : tables, défaut, tours et réglages. Chaque commande acceptée
|
||
|
|
// rend une charge que l'analyse relit et qui se normalise quand la charge
|
||
|
|
// reçue se normalisait ; un refus ne change rien. Les gestes qui comptent
|
||
|
|
// les entrées du journal, ou les avertissements que la séance ajoute,
|
||
|
|
// passent par seance.executer sur le système de fichiers d'épreuve. Les noms
|
||
|
|
// d'épreuve sont inventés ; la version vient du module engendré.
|
||
|
|
import assert from 'node:assert/strict';
|
||
|
|
import { creerFichiersSimules } from '../../test/fichiers_simules.js';
|
||
|
|
import { describe, test } from '../../test/lanceur.js';
|
||
|
|
import { caseLibre } from '../geometrie/tables.js';
|
||
|
|
import { STATUT, nombrePlacesManquantes, normaliser } from '../moteur/configuration.js';
|
||
|
|
import { ErreurConfiguration } from '../moteur/erreurs.js';
|
||
|
|
import { serialiser } from '../stockage/canonique.js';
|
||
|
|
import { creer as creerDansLeDepot } from '../stockage/depot.js';
|
||
|
|
import { analyser, capacite, configurationDepuisCharge, creerCharge } from '../stockage/document.js';
|
||
|
|
import { lireJournal } from '../stockage/journal.js';
|
||
|
|
import { SUFFIXES } from '../stockage/noms.js';
|
||
|
|
import { derive, examiner, fautes } from '../stockage/placements.js';
|
||
|
|
import { VERSION } from '../version.genere.js';
|
||
|
|
import { invariantViole } from './avertissements.js';
|
||
|
|
import { COMMANDES, appliquerCommande } from './commandes.js';
|
||
|
|
import { COMMANDES_MOBILIER } from './commandes_mobilier.js';
|
||
|
|
import { ErreurCommande } from './erreurs.js';
|
||
|
|
import { libelle } from './libelles.js';
|
||
|
|
import { etatPlaces } from './places.js';
|
||
|
|
import { creerSeance } from './seance.js';
|
||
|
|
|
||
|
|
const V1 = VERSION.affichee;
|
||
|
|
const NOM = 'Soirée des Merles';
|
||
|
|
const DOC = { id: 'documents', chemin: 'C:\\Users\\Exemple\\Documents\\Gestion table tournante Libre' };
|
||
|
|
|
||
|
|
const NOMS = [
|
||
|
|
['Ombrelle', 'Iris'],
|
||
|
|
['Pervenche', 'Théo'],
|
||
|
|
['Lacasse', 'Ondine'],
|
||
|
|
['Grisaille', null],
|
||
|
|
['Bruyère', 'Anouk'],
|
||
|
|
['Sarcelle', 'Capucine'],
|
||
|
|
['Ancolie', 'Amandine'],
|
||
|
|
['Mélèze', 'Basile'],
|
||
|
|
['Quenouille', 'Hortense'],
|
||
|
|
['Pivoine', 'Gaspard'],
|
||
|
|
];
|
||
|
|
|
||
|
|
const personne = (id, autres = {}) => ({
|
||
|
|
id,
|
||
|
|
nom: NOMS[(id - 1) % NOMS.length][0],
|
||
|
|
prenom: NOMS[(id - 1) % NOMS.length][1],
|
||
|
|
appartenance: null,
|
||
|
|
courriel: null,
|
||
|
|
titrePressenti: null,
|
||
|
|
notes: null,
|
||
|
|
exclu: false,
|
||
|
|
...autres,
|
||
|
|
});
|
||
|
|
|
||
|
|
const resa = (participant, table, siege, tour = null) => ({ participant, table, siege, portee: tour === null ? 'tous' : 'tour', tour });
|
||
|
|
const suite = (de, a) => Array.from({ length: a - de + 1 }, (_, rang) => de + rang);
|
||
|
|
const afficherTour = (tour) => ({ geste: 'afficherTour', tour, proposition: null });
|
||
|
|
|
||
|
|
// Une charge : les tables données ({id, sieges}, numéro égal à l'identifiant
|
||
|
|
// sauf indication), n personnes dont les exclus, R tours, un défaut.
|
||
|
|
function chargeDe({ tables = [], n = 0, exclus = [], tours = 2, defaut = 8, attribuerSieges = false, reservations = [], titres = [] } = {}) {
|
||
|
|
const charge = creerCharge({ id: 'evt-mobilier', nom: NOM, siegesParDefaut: defaut, tours });
|
||
|
|
charge.reglages.attribuerSieges = attribuerSieges;
|
||
|
|
charge.participants = Array.from({ length: n }, (_, rang) => personne(rang + 1, { exclu: exclus.includes(rang + 1) }));
|
||
|
|
charge.tables = tables.map(({ id, numero = id, sieges = null }) => ({ id, numero, sieges, forme: 'ronde', position: { x: 300 * id, y: 0 } }));
|
||
|
|
charge.reservations = reservations;
|
||
|
|
charge.titres = titres;
|
||
|
|
charge.prochainsIds = { participant: n + 1, table: Math.max(0, ...tables.map(({ id }) => id)) + 1, proposition: 1 };
|
||
|
|
return charge;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ajoute la proposition id, ses listes dans l'ordre de charge.tables, et la
|
||
|
|
// retient quand retenu est vrai.
|
||
|
|
function placer(charge, listes, { id, retenu = false }) {
|
||
|
|
const participants = charge.participants.filter(({ exclu }) => !exclu).map(({ id: p }) => p);
|
||
|
|
const plan = {
|
||
|
|
siegesAttribues: charge.reglages.attribuerSieges,
|
||
|
|
tables: charge.tables.map(({ id: t }) => t),
|
||
|
|
capacites: charge.tables.map((table) => capacite(charge, table)),
|
||
|
|
tours: listes.length,
|
||
|
|
participants,
|
||
|
|
placement: listes.map((tour) => ({ sieges: tour, reserve: participants.filter((p) => !tour.flat().includes(p)) })),
|
||
|
|
};
|
||
|
|
charge.propositions.push({ id, graine: id, arret: 40, historique: 1000, produitVersion: V1, ...plan });
|
||
|
|
charge.prochainsIds.proposition = id + 1;
|
||
|
|
if (retenu) {
|
||
|
|
charge.retenu = { proposition: id, ...structuredClone(plan) };
|
||
|
|
charge.evenement.etat = 'retenu';
|
||
|
|
} else if (charge.evenement.etat === 'brouillon') {
|
||
|
|
charge.evenement.etat = 'propose';
|
||
|
|
}
|
||
|
|
return charge;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Gèle une valeur en profondeur : une commande qui la modifierait lèverait.
|
||
|
|
function figer(valeur) {
|
||
|
|
if (valeur !== null && typeof valeur === 'object' && !Object.isFrozen(valeur)) {
|
||
|
|
Object.freeze(valeur);
|
||
|
|
for (const element of Object.values(valeur)) figer(element);
|
||
|
|
}
|
||
|
|
return valeur;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Vrai quand la configuration de la charge se normalise.
|
||
|
|
function seNormalise(charge) {
|
||
|
|
try {
|
||
|
|
normaliser(configurationDepuisCharge(charge));
|
||
|
|
return true;
|
||
|
|
} catch (erreur) {
|
||
|
|
if (erreur instanceof ErreurConfiguration) return false;
|
||
|
|
throw erreur;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Une commande acceptée, sur une copie gelée de la charge : la charge rendue
|
||
|
|
// se relit, et se normalise quand la charge reçue se normalisait.
|
||
|
|
function accepter(nom, charge, args) {
|
||
|
|
const recue = figer(structuredClone(charge));
|
||
|
|
const rendu = appliquerCommande(nom, recue, args);
|
||
|
|
analyser(serialiser(rendu.charge, { revision: 1, produitVersion: 'essai' }));
|
||
|
|
if (seNormalise(recue)) assert.ok(seNormalise(rendu.charge), `${nom} : la charge rendue ne se normalise plus`);
|
||
|
|
return rendu;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Le refus d'une ErreurCommande de ce code ; ses détails contiennent ceux
|
||
|
|
// donnés.
|
||
|
|
function refuse(appel, code, attendus = {}) {
|
||
|
|
let leve = null;
|
||
|
|
try {
|
||
|
|
appel();
|
||
|
|
} catch (erreur) {
|
||
|
|
leve = erreur;
|
||
|
|
}
|
||
|
|
assert.ok(leve instanceof ErreurCommande, `ErreurCommande ${code} attendue, reçu ${leve}`);
|
||
|
|
assert.equal(leve.code, code, leve.message);
|
||
|
|
for (const [cle, valeur] of Object.entries(attendus)) assert.deepEqual(leve.details[cle], valeur, cle);
|
||
|
|
return leve;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Le même refus, rendu par une promesse.
|
||
|
|
async function refuseAsync(promesse, code, attendus = {}) {
|
||
|
|
let leve = null;
|
||
|
|
try {
|
||
|
|
await promesse;
|
||
|
|
} catch (erreur) {
|
||
|
|
leve = erreur;
|
||
|
|
}
|
||
|
|
return refuse(() => {
|
||
|
|
if (leve !== null) throw leve;
|
||
|
|
}, code, attendus);
|
||
|
|
}
|
||
|
|
|
||
|
|
// --- La séance d'épreuve ----------------------------------------------------
|
||
|
|
|
||
|
|
// Une séance sur le système d'épreuve, l'événement de la charge posé par le
|
||
|
|
// dépôt, ouvert et passé en écriture. entrees() compte les entrées du
|
||
|
|
// journal ; ecritures() les écritures du système.
|
||
|
|
async function seanceSur(charge) {
|
||
|
|
const fs = creerFichiersSimules();
|
||
|
|
fs.deposerDossier('documents');
|
||
|
|
await creerDansLeDepot(fs, DOC, charge, {
|
||
|
|
libelle: libelle('ENTREE_CREATION', { nom: NOM }),
|
||
|
|
nomJalon: libelle('JALON_CREATION'),
|
||
|
|
horodatage: '2031-05-17T07:00:00-04:00',
|
||
|
|
produitVersion: V1,
|
||
|
|
});
|
||
|
|
let tirage = 0;
|
||
|
|
const seance = creerSeance({
|
||
|
|
fs,
|
||
|
|
racine: DOC,
|
||
|
|
horloge: { horodatage: () => '2031-05-17T08:00:00-04:00' },
|
||
|
|
identifiant: () => {
|
||
|
|
tirage += 1;
|
||
|
|
return `seance-${tirage}`;
|
||
|
|
},
|
||
|
|
produitVersion: V1,
|
||
|
|
planifier: () => 1,
|
||
|
|
annuler: () => {},
|
||
|
|
});
|
||
|
|
await seance.ouvrir(NOM);
|
||
|
|
await seance.passerEnEcriture();
|
||
|
|
return {
|
||
|
|
seance,
|
||
|
|
entrees: () => lireJournal(fs.contenu('documents', `${NOM}${SUFFIXES.journal}`)).entrees.length,
|
||
|
|
ecritures: () => fs.compteurs.ecritures,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// --- Les épreuves -----------------------------------------------------------
|
||
|
|
|
||
|
|
describe('mobilier : le registre (§ 8.2)', () => {
|
||
|
|
test('COMMANDES_MOBILIER porte les huit commandes du mobilier, réunies dans COMMANDES', () => {
|
||
|
|
const noms = ['creerTable', 'supprimerTable', 'deplacerTable', 'changerPlacesTable', 'realignerTable', 'changerDefaut', 'changerTours', 'modifierReglage'];
|
||
|
|
assert.deepEqual([...COMMANDES_MOBILIER.keys()], noms);
|
||
|
|
for (const nom of noms) assert.equal(COMMANDES.get(nom), COMMANDES_MOBILIER.get(nom), nom);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('un plan bloqué refuse chacune, PLAN_BLOQUE, remède debloquer', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }], n: 2 });
|
||
|
|
charge.evenement.etat = 'bloque';
|
||
|
|
const gestes = [
|
||
|
|
['creerTable', { forme: 'ronde' }],
|
||
|
|
['supprimerTable', { id: 1 }],
|
||
|
|
['deplacerTable', { id: 1, position: { x: 5, y: 5 } }],
|
||
|
|
['changerPlacesTable', { id: 1, sieges: 6, origine: 'champ' }],
|
||
|
|
['realignerTable', { id: 1 }],
|
||
|
|
['changerDefaut', { sieges: 6, realigner: false }],
|
||
|
|
['changerTours', { tours: 3 }],
|
||
|
|
['modifierReglage', { cle: 'nouveauxVoisins', valeur: false }],
|
||
|
|
];
|
||
|
|
assert.equal(gestes.length, COMMANDES_MOBILIER.size);
|
||
|
|
for (const [nom, args] of gestes) {
|
||
|
|
refuse(() => COMMANDES.get(nom)(charge, args), 'PLAN_BLOQUE', { remede: { geste: 'debloquer' } });
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('mobilier : créer, déplacer et supprimer une table (§ 4, § 6.1, § 9)', () => {
|
||
|
|
test("les identifiants ne se réutilisent jamais ; le numéro suit le plus grand, et le libellé nomme le numéro", () => {
|
||
|
|
let charge = chargeDe();
|
||
|
|
for (let i = 0; i < 3; i += 1) charge = accepter('creerTable', charge, { forme: 'ronde' }).charge;
|
||
|
|
assert.deepEqual(charge.tables.map(({ id, numero }) => [id, numero]), [[1, 1], [2, 2], [3, 3]]);
|
||
|
|
charge = accepter('supprimerTable', charge, { id: 3 }).charge;
|
||
|
|
const cree = accepter('creerTable', charge, { forme: 'carree' });
|
||
|
|
assert.equal(cree.libelle, 'Ajouté la table 3');
|
||
|
|
assert.deepEqual(cree.charge.tables.at(-1), {
|
||
|
|
id: 4,
|
||
|
|
numero: 3,
|
||
|
|
sieges: null,
|
||
|
|
forme: 'carree',
|
||
|
|
position: caseLibre(charge.tables.map(({ position }) => position)),
|
||
|
|
});
|
||
|
|
assert.equal(cree.charge.prochainsIds.table, 5);
|
||
|
|
const deplace = accepter('deplacerTable', cree.charge, { id: 4, position: { x: 612.4, y: -0.4 } });
|
||
|
|
assert.equal(deplace.libelle, 'Déplacé la table 3');
|
||
|
|
assert.deepEqual(deplace.charge.tables.at(-1).position, { x: 612, y: 0 });
|
||
|
|
assert.ok(Object.is(deplace.charge.tables.at(-1).position.y, 0));
|
||
|
|
// Une position que l'arrondi ne change pas : le geste est sans effet.
|
||
|
|
refuse(() => appliquerCommande('deplacerTable', deplace.charge, { id: 4, position: { x: 611.6, y: 0.2 } }), 'SANS_EFFET');
|
||
|
|
|
||
|
|
// Supprimer une table du milieu : le numéro suit encore le plus grand,
|
||
|
|
// et non le nombre de tables.
|
||
|
|
let milieu = chargeDe();
|
||
|
|
for (let i = 0; i < 3; i += 1) milieu = accepter('creerTable', milieu, { forme: 'ronde' }).charge;
|
||
|
|
milieu = accepter('supprimerTable', milieu, { id: 2 }).charge;
|
||
|
|
const apresMilieu = accepter('creerTable', milieu, { forme: 'ronde' });
|
||
|
|
assert.equal(apresMilieu.libelle, 'Ajouté la table 4');
|
||
|
|
assert.deepEqual(apresMilieu.charge.tables.map(({ id, numero }) => [id, numero]), [[1, 1], [3, 3], [4, 4]]);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('une forme inconnue, une table inconnue ou une position non finie sont des fautes du code', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }] });
|
||
|
|
assert.throws(() => COMMANDES.get('creerTable')(charge, { forme: 'ovale' }), TypeError);
|
||
|
|
assert.throws(() => COMMANDES.get('supprimerTable')(charge, { id: 7 }), TypeError);
|
||
|
|
assert.throws(() => COMMANDES.get('deplacerTable')(charge, { id: 1, position: { x: Number.NaN, y: 0 } }), TypeError);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('une table créée suit le défaut : sieges null, 8 places sous un défaut de 8, 10 sous un défaut de 10', () => {
|
||
|
|
for (const defaut of [8, 10]) {
|
||
|
|
const { charge } = accepter('creerTable', chargeDe({ defaut }), { forme: 'ronde' });
|
||
|
|
assert.equal(charge.tables[0].sieges, null);
|
||
|
|
assert.equal(capacite(charge, charge.tables[0]), defaut);
|
||
|
|
}
|
||
|
|
const huit = accepter('creerTable', chargeDe(), { forme: 'ronde' }).charge;
|
||
|
|
const dix = accepter('changerDefaut', huit, { sieges: 10, realigner: false }).charge;
|
||
|
|
assert.equal(capacite(dix, dix.tables[0]), 10);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('une table créée après la retenue entre au retenu, vide à chaque tour ; les propositions dérivent TABLE_AJOUTEE', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 6 });
|
||
|
|
const listes = [[[1, 2, 3], [4, 5, 6]], [[1, 4, 5], [2, 3, 6]]];
|
||
|
|
placer(charge, listes, { id: 1 });
|
||
|
|
placer(charge, listes, { id: 2, retenu: true });
|
||
|
|
const { charge: apres, libelle: texte } = accepter('creerTable', charge, { forme: 'ronde' });
|
||
|
|
assert.equal(texte, 'Ajouté la table 3');
|
||
|
|
assert.deepEqual(apres.retenu.tables, [1, 2, 3]);
|
||
|
|
assert.deepEqual(apres.retenu.capacites, [8, 8, 8]);
|
||
|
|
for (const { sieges } of apres.retenu.placement) assert.deepEqual(sieges.at(-1), []);
|
||
|
|
assert.deepEqual(fautes(apres.retenu), []);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), []);
|
||
|
|
assert.deepEqual(apres.propositions, charge.propositions);
|
||
|
|
assert.deepEqual(examiner(apres).derives, [
|
||
|
|
{ id: 1, raisons: [{ code: 'TABLE_AJOUTEE', table: 3 }] },
|
||
|
|
{ id: 2, raisons: [{ code: 'TABLE_AJOUTEE', table: 3 }] },
|
||
|
|
]);
|
||
|
|
// Un retenu fautif ne se réécrit pas.
|
||
|
|
const fautif = structuredClone(charge);
|
||
|
|
fautif.retenu.capacites = [8];
|
||
|
|
const sansRetouche = accepter('creerTable', fautif, { forme: 'ronde' }).charge;
|
||
|
|
assert.deepEqual(sansRetouche.retenu, fautif.retenu);
|
||
|
|
});
|
||
|
|
|
||
|
|
test("identifiant contre numéro : supprimer la table 2 laisse la réservation et les listes de la table 3 du retenu", () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }, { id: 3 }], n: 6, reservations: [resa(1, 3, null)] });
|
||
|
|
placer(charge, [[[2, 3], [4, 5], [1, 6]], [[4, 6], [2, 3], [1, 5]]], { id: 1, retenu: true });
|
||
|
|
const { charge: apres, libelle: texte } = accepter('supprimerTable', charge, { id: 2 });
|
||
|
|
assert.equal(texte, 'Supprimé la table 2');
|
||
|
|
assert.deepEqual(apres.tables.map(({ id, numero }) => [id, numero]), [[1, 1], [3, 3]]);
|
||
|
|
assert.deepEqual(apres.reservations, [resa(1, 3, null)]);
|
||
|
|
assert.deepEqual(apres.retenu, charge.retenu);
|
||
|
|
assert.ok(examiner(apres).retenu.raisons.some(({ code, table }) => code === 'TABLE_SUPPRIMEE' && table === 2));
|
||
|
|
});
|
||
|
|
|
||
|
|
test("supprimer une table garnie retire, dans la même entrée, ses réservations et ses titres", async () => {
|
||
|
|
const charge = chargeDe({
|
||
|
|
tables: [{ id: 1 }, { id: 2 }],
|
||
|
|
n: 4,
|
||
|
|
reservations: [resa(2, 2, 2), resa(1, 1, null), resa(3, 2, null, 1)],
|
||
|
|
titres: [{ table: 2, siege: 2, libelle: 'animateur' }, { table: 1, siege: 1, libelle: 'accueil' }],
|
||
|
|
});
|
||
|
|
const { seance, entrees } = await seanceSur(charge);
|
||
|
|
const avant = entrees();
|
||
|
|
const rendu = await seance.executer('supprimerTable', { id: 2 });
|
||
|
|
assert.equal(rendu.libelle, 'Supprimé la table 2 ; retirés : 2 réservations et 1 titre');
|
||
|
|
assert.equal(entrees() - avant, 1);
|
||
|
|
assert.deepEqual(seance.charge.reservations, [resa(1, 1, null)]);
|
||
|
|
assert.deepEqual(seance.charge.titres, [{ table: 1, siege: 1, libelle: 'accueil' }]);
|
||
|
|
// Au singulier : une réservation, un titre ; une table nue ne retire rien.
|
||
|
|
const seule = await seance.executer('supprimerTable', { id: 1 });
|
||
|
|
assert.equal(seule.libelle, 'Supprimé la table 1 ; retirés : 1 réservation et 1 titre');
|
||
|
|
const vide = accepter('supprimerTable', chargeDe({ tables: [{ id: 4 }] }), { id: 4 });
|
||
|
|
assert.equal(vide.libelle, 'Supprimé la table 4');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('le manque : supprimer une table de 8 sous Σ c = N = 16 avertit PLACES_MANQUANTES {8} ; ramener une table à 6, {2}', async () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 16 });
|
||
|
|
const un = await seanceSur(charge);
|
||
|
|
const rendu = await un.seance.executer('supprimerTable', { id: 2 });
|
||
|
|
assert.equal(nombrePlacesManquantes(normaliser(configurationDepuisCharge(un.seance.charge))), 8);
|
||
|
|
assert.deepEqual(rendu.avertissements, [{ code: 'PLACES_MANQUANTES', details: { placesManquantes: 8 } }]);
|
||
|
|
const deux = await seanceSur(charge);
|
||
|
|
const reduit = await deux.seance.executer('changerPlacesTable', { id: 1, sieges: 6, origine: 'champ' });
|
||
|
|
assert.deepEqual(reduit.avertissements, [{ code: 'PLACES_MANQUANTES', details: { placesManquantes: 2 } }]);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe("mobilier : les places d'une table, par le champ et par la poignée (§ 6.2, § 7.1)", () => {
|
||
|
|
test('les saisies : « 1 » et « 0 » refusent MOINS_DE_DEUX ; un texte non entier, NON_ENTIER ; « 2 » passe', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }], n: 2 });
|
||
|
|
for (const sieges of ['1', '0']) {
|
||
|
|
refuse(() => COMMANDES.get('changerPlacesTable')(charge, { id: 1, sieges, origine: 'champ' }), 'MOINS_DE_DEUX', { remede: null });
|
||
|
|
}
|
||
|
|
const textes = ['-3', '2.5', '2,5', '8abc', 'huit', ''];
|
||
|
|
assert.equal(textes.length, 6);
|
||
|
|
for (const sieges of textes) {
|
||
|
|
refuse(() => COMMANDES.get('changerPlacesTable')(charge, { id: 1, sieges, origine: 'champ' }), 'NON_ENTIER', { saisie: sieges, remede: null });
|
||
|
|
}
|
||
|
|
const deux = accepter('changerPlacesTable', charge, { id: 1, sieges: '2', origine: 'champ' });
|
||
|
|
assert.equal(deux.charge.tables[0].sieges, 2);
|
||
|
|
assert.equal(deux.libelle, 'Table 1 : 2 places');
|
||
|
|
});
|
||
|
|
|
||
|
|
test("une surcharge au défaut est une surcharge ; réaligner la retire, et le libellé nomme le défaut", () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 5, numero: 2 }], n: 2 });
|
||
|
|
const surchargee = accepter('changerPlacesTable', charge, { id: 5, sieges: 8, origine: 'champ' });
|
||
|
|
assert.equal(surchargee.charge.tables[0].sieges, 8);
|
||
|
|
assert.equal(surchargee.libelle, 'Table 2 : 8 places');
|
||
|
|
const realignee = accepter('realignerTable', surchargee.charge, { id: 5 });
|
||
|
|
assert.equal(realignee.charge.tables[0].sieges, null);
|
||
|
|
assert.equal(realignee.libelle, 'Table 2 : suit le défaut (8 places)');
|
||
|
|
refuse(() => appliquerCommande('realignerTable', realignee.charge, { id: 5 }), 'SANS_EFFET');
|
||
|
|
});
|
||
|
|
|
||
|
|
test("le champ dans le retenu, sièges attribués : les occupants des chaises 7 et 8 passent en réserve, la capacité du retenu suit", () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }, { id: 3 }], n: 18, attribuerSieges: true });
|
||
|
|
placer(
|
||
|
|
charge,
|
||
|
|
[
|
||
|
|
[suite(1, 6), suite(7, 12), suite(13, 18)],
|
||
|
|
[suite(1, 5), suite(6, 10), [18, 11, 12, 13, 14, 15, 16, 17]],
|
||
|
|
],
|
||
|
|
{ id: 1, retenu: true },
|
||
|
|
);
|
||
|
|
const chaises = etatPlaces(charge, { tour: 2 }).tables[2].chaises;
|
||
|
|
const personnes = [chaises[6].occupant, chaises[7].occupant];
|
||
|
|
assert.deepEqual(personnes, [16, 17]);
|
||
|
|
const { charge: apres, avertissements, libelle: texte } = accepter('changerPlacesTable', charge, { id: 3, sieges: 6, origine: 'champ' });
|
||
|
|
assert.equal(texte, 'Table 3 : 6 places');
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 3, tour: 2, personnes } }]);
|
||
|
|
const etage = apres.retenu.placement[1];
|
||
|
|
assert.deepEqual(etage.sieges[2], [18, 11, 12, 13, 14, 15]);
|
||
|
|
assert.deepEqual(etage.reserve, [16, 17]);
|
||
|
|
assert.deepEqual([...etage.sieges.flat(), ...etage.reserve].sort((a, b) => a - b), suite(1, 18));
|
||
|
|
assert.deepEqual(apres.retenu.placement[0], charge.retenu.placement[0]);
|
||
|
|
assert.deepEqual(apres.retenu.capacites, [8, 8, 6]);
|
||
|
|
assert.deepEqual(fautes(apres.retenu), []);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), []);
|
||
|
|
assert.deepEqual(apres.propositions, charge.propositions);
|
||
|
|
assert.deepEqual(derive(apres.propositions[0], apres), [{ code: 'CAPACITE_CHANGEE', table: 3, avant: 8, maintenant: 6 }]);
|
||
|
|
});
|
||
|
|
|
||
|
|
test("le champ dans le retenu, sièges non attribués : la personne réservée au siège 2 reste, les deux suivantes partent", () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }, { id: 3 }], n: 18, reservations: [resa(18, 3, 2)] });
|
||
|
|
placer(
|
||
|
|
charge,
|
||
|
|
[
|
||
|
|
[suite(1, 6), suite(7, 12), suite(13, 18)],
|
||
|
|
[suite(1, 5), suite(6, 10), suite(11, 18)],
|
||
|
|
],
|
||
|
|
{ id: 1, retenu: true },
|
||
|
|
);
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', charge, { id: 3, sieges: 6, origine: 'champ' });
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 3, tour: 2, personnes: [16, 17] } }]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[1].sieges[2], [11, 12, 13, 14, 15, 18]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[1].reserve, [16, 17]);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), []);
|
||
|
|
// La personne réservée garde sa place au plan, au siège 2.
|
||
|
|
assert.equal(etatPlaces(apres, { tour: 2 }).tables[2].chaises[1].occupant, 18);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('sièges attribués : une liste réduite ne finit jamais par une chaise vide ; fautes(retenu) reste vide', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, attribuerSieges: true });
|
||
|
|
placer(charge, [[suite(1, 6), [7, 8, 9, 10, 11, null, null, 12]]], { id: 1, retenu: true });
|
||
|
|
for (const sieges of [6, 7]) {
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', charge, { id: 2, sieges, origine: 'champ' });
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].sieges[1], [7, 8, 9, 10, 11]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].reserve, [12]);
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 2, tour: 1, personnes: [12] } }]);
|
||
|
|
assert.deepEqual(fautes(apres.retenu), []);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
test('la poignée : 8 → 9 accepté, la capacité du retenu suit ; sous l\'occupation, SOUS_OCCUPES et rien ne change', () => {
|
||
|
|
const cinq = suite(1, 5);
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }], n: 7, tours: 4 });
|
||
|
|
placer(charge, [cinq, cinq, suite(1, 7), cinq].map((liste) => [liste]), { id: 1, retenu: true });
|
||
|
|
const neuf = accepter('changerPlacesTable', charge, { id: 1, sieges: 9, origine: 'poignee' });
|
||
|
|
assert.deepEqual(neuf.charge.retenu.capacites, [9]);
|
||
|
|
assert.deepEqual(neuf.charge.retenu.placement, charge.retenu.placement);
|
||
|
|
assert.deepEqual(neuf.avertissements, []);
|
||
|
|
refuse(() => COMMANDES.get('changerPlacesTable')(charge, { id: 1, sieges: 6, origine: 'poignee' }), 'SOUS_OCCUPES', {
|
||
|
|
table: 1,
|
||
|
|
n: 7,
|
||
|
|
tour: 3,
|
||
|
|
remede: afficherTour(3),
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
test('réaligner une table surchargée à 10 qui en assied dix, sous un défaut de 8 : deux surnuméraires', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1, sieges: 10 }, { id: 2 }], n: 16, tours: 1 });
|
||
|
|
placer(charge, [[suite(1, 10), suite(11, 16)]], { id: 1, retenu: true });
|
||
|
|
const { charge: apres, avertissements, libelle: texte } = accepter('realignerTable', charge, { id: 1 });
|
||
|
|
assert.equal(texte, 'Table 1 : suit le défaut (8 places)');
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 1, tour: 1, personnes: [9, 10] } }]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].reserve, [9, 10]);
|
||
|
|
assert.deepEqual(apres.retenu.capacites, [8, 8]);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), []);
|
||
|
|
});
|
||
|
|
|
||
|
|
test("une hausse n'assied personne que le plan ne montrait pas : un retenu déclaré à 10 sur une table de 8", () => {
|
||
|
|
// Avec la personne 9 réservée à la table 1 sans siège : sièges attribués,
|
||
|
|
// son rang 9 ne se montre pas et la hausse ne l'assied pas ; sans
|
||
|
|
// attribution, l'affichage l'élit déjà, et la personne 8 n'est pas montrée.
|
||
|
|
// La dérive du retenu masquait la réservation non tenue de la personne 9 ;
|
||
|
|
// la capacité rejointe, invariantViole la nomme.
|
||
|
|
const nonTenue = { code: 'INVARIANT_VIOLE', details: { proposition: 1, violations: [{ code: 'RESERVATION', participant: 9, table: 1, tour: 1 }] } };
|
||
|
|
const cas = [
|
||
|
|
{ attribuerSieges: true, reservations: [], liste: suite(1, 8), reserve: [9, 10], invariant: null },
|
||
|
|
{ attribuerSieges: false, reservations: [], liste: suite(1, 8), reserve: [9, 10], invariant: null },
|
||
|
|
{ attribuerSieges: true, reservations: [resa(9, 1, null)], liste: suite(1, 8), reserve: [9, 10], invariant: nonTenue },
|
||
|
|
{ attribuerSieges: false, reservations: [resa(9, 1, null)], liste: [1, 2, 3, 4, 5, 6, 7, 9], reserve: [8, 10], invariant: null },
|
||
|
|
];
|
||
|
|
for (const { attribuerSieges, reservations, liste, reserve, invariant } of cas) {
|
||
|
|
for (const origine of ['champ', 'poignee']) {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1, sieges: 10 }, { id: 2 }], n: 12, tours: 1, attribuerSieges, reservations });
|
||
|
|
placer(charge, [[suite(1, 10), [11, 12]]], { id: 1, retenu: true });
|
||
|
|
charge.tables[0].sieges = null;
|
||
|
|
const montrees = etatPlaces(charge, { tour: 1 }).tables[0].chaises.map(({ occupant }) => occupant);
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', charge, { id: 1, sieges: 10, origine });
|
||
|
|
const nom = `attribuerSieges ${attribuerSieges}, ${reservations.length} réservation, ${origine}`;
|
||
|
|
assert.deepEqual(montrees, liste, nom);
|
||
|
|
assert.deepEqual(avertissements, [], nom);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].sieges[0], liste, nom);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].reserve, reserve, nom);
|
||
|
|
assert.deepEqual(apres.retenu.capacites, [10, 8], nom);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), [], nom);
|
||
|
|
assert.equal(invariantViole(charge), null, nom);
|
||
|
|
assert.deepEqual(invariantViole(apres), invariant, nom);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
test('un retenu de plus de tours que la soirée se réduit à chacun de ses tours, sans faute', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, tours: 3, attribuerSieges: true });
|
||
|
|
placer(charge, [[suite(1, 6), suite(7, 12)], [suite(1, 6), suite(7, 12)], [suite(1, 4), suite(5, 12)]], { id: 1, retenu: true });
|
||
|
|
const deux = accepter('changerTours', charge, { tours: 2 }).charge;
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', deux, { id: 2, sieges: 6, origine: 'champ' });
|
||
|
|
// Le tour 3 n'est plus de la soirée, mais le retenu le porte encore : ses
|
||
|
|
// surnuméraires se nomment comme ceux d'un tour montré.
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 2, tour: 3, personnes: [11, 12] } }]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[2].sieges[1], suite(5, 10));
|
||
|
|
assert.deepEqual(apres.retenu.placement[2].reserve, [11, 12]);
|
||
|
|
assert.deepEqual(fautes(apres.retenu), []);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('sans attribution, un tour du retenu que la soirée n\'a plus élit aussi la personne que la table réserve', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, tours: 3, reservations: [resa(12, 2, null)] });
|
||
|
|
placer(charge, [[suite(1, 6), suite(7, 12)], [suite(1, 6), suite(7, 12)], [suite(1, 4), suite(5, 12)]], { id: 1, retenu: true });
|
||
|
|
const deux = accepter('changerTours', charge, { tours: 2 }).charge;
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', deux, { id: 2, sieges: 6, origine: 'champ' });
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 2, tour: 3, personnes: [10, 11] } }]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[2].sieges[1], [5, 6, 7, 8, 9, 12]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[2].reserve, [10, 11]);
|
||
|
|
assert.deepEqual(fautes(apres.retenu), []);
|
||
|
|
});
|
||
|
|
|
||
|
|
test("une réduction acceptée garde chaque réservation que le retenu tenait : invariantViole reste null", () => {
|
||
|
|
// La personne 8, réservée à la table 1 sans siège, est assise à la chaise 8.
|
||
|
|
const gestes = [
|
||
|
|
['changerPlacesTable', { id: 1, sieges: 6, origine: 'champ' }],
|
||
|
|
['changerDefaut', { sieges: 6, realigner: false }],
|
||
|
|
];
|
||
|
|
let acceptees = 0;
|
||
|
|
for (const attribuerSieges of [true, false]) {
|
||
|
|
for (const [nom, args] of gestes) {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, tours: 1, attribuerSieges, reservations: [resa(8, 1, null)] });
|
||
|
|
placer(charge, [[suite(1, 8), suite(9, 12)]], { id: 1, retenu: true });
|
||
|
|
assert.equal(invariantViole(charge), null);
|
||
|
|
const { charge: apres, avertissements } = accepter(nom, charge, args);
|
||
|
|
const cas = `${nom}, attribuerSieges ${attribuerSieges}`;
|
||
|
|
assert.equal(invariantViole(apres), null, cas);
|
||
|
|
// Un non-réservé cède sa chaise : la chaise 6, la plus haute, sous des
|
||
|
|
// sièges attribués ; sinon l'affichage élit d'abord la réservée.
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].sieges[0], [1, 2, 3, 4, 5, 8], cas);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].reserve, [6, 7], cas);
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 1, tour: 1, personnes: [6, 7] } }], cas);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), [], cas);
|
||
|
|
acceptees += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
assert.equal(acceptees, 4);
|
||
|
|
|
||
|
|
// Sièges attribués, une chaise vide dans la capacité reçoit la réservée
|
||
|
|
// avant qu'un non-réservé ne cède la sienne.
|
||
|
|
const vide = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, tours: 1, attribuerSieges: true, reservations: [resa(8, 1, null)] });
|
||
|
|
placer(vide, [[[1, 2, 3, null, 5, 6, 7, 8], suite(9, 12)]], { id: 1, retenu: true });
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', vide, { id: 1, sieges: 6, origine: 'champ' });
|
||
|
|
assert.equal(invariantViole(apres), null);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].sieges[0], [1, 2, 3, 8, 5, 6]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].reserve, [4, 7]);
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 1, tour: 1, personnes: [7] } }]);
|
||
|
|
|
||
|
|
// Réaligner une table surchargée à 10, la personne 10 réservée sans siège.
|
||
|
|
const dix = chargeDe({ tables: [{ id: 1, sieges: 10 }, { id: 2 }], n: 14, tours: 1, attribuerSieges: true, reservations: [resa(10, 1, null)] });
|
||
|
|
placer(dix, [[suite(1, 10), suite(11, 14)]], { id: 1, retenu: true });
|
||
|
|
const realignee = accepter('realignerTable', dix, { id: 1 });
|
||
|
|
assert.equal(invariantViole(realignee.charge), null);
|
||
|
|
assert.deepEqual(realignee.charge.retenu.placement[0].sieges[0], [1, 2, 3, 4, 5, 6, 7, 10]);
|
||
|
|
assert.deepEqual(realignee.avertissements, [{ code: 'SURNUMERAIRES', details: { table: 1, tour: 1, personnes: [8, 9] } }]);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('sièges attribués, le retour des réservés : siège voulu, chaise libre ou d\'un absent, non-réservé du plus haut rang, ordre des rangs, tour couvert', () => {
|
||
|
|
// La table 1, de 8, réduite à 6 par le champ ; les exclus le deviennent
|
||
|
|
// après la retenue. Par tour : la liste qui reste, la réserve, et les
|
||
|
|
// personnes de SURNUMERAIRES.
|
||
|
|
const cas = [
|
||
|
|
{
|
||
|
|
nom: "une chaise tenue par un absent est libre : la personne 8 la prend, l'absent 2 passe en réserve",
|
||
|
|
reservations: [resa(8, 1, null)],
|
||
|
|
exclus: [2],
|
||
|
|
listes: [[suite(1, 8), suite(9, 12)]],
|
||
|
|
attendus: [[[1, 8, 3, 4, 5, 6], [2, 7], [7]]],
|
||
|
|
},
|
||
|
|
{
|
||
|
|
nom: 'le siège réservé, libre, passe avant la première chaise libre',
|
||
|
|
reservations: [resa(9, 1, 3), resa(9, 1, 4, 1)],
|
||
|
|
listes: [[[1, null, null, null, 5, 6, 7, 9], [2, 3, 4, 8, 10, 11, 12]]],
|
||
|
|
attendus: [[[1, null, 9, null, 5, 6], [7], [7]]],
|
||
|
|
},
|
||
|
|
{
|
||
|
|
nom: "le siège réservé est le premier siège non nul des réservations de la personne, dans l'ordre canonique",
|
||
|
|
reservations: [resa(9, 1, null), resa(9, 1, 4, 1)],
|
||
|
|
listes: [[[1, null, null, null, 5, 6, 7, 9], [2, 3, 4, 8, 10, 11, 12]]],
|
||
|
|
attendus: [[[1, null, null, 9, 5, 6], [7], [7]]],
|
||
|
|
},
|
||
|
|
{
|
||
|
|
nom: "un siège réservé tenu par une personne présente n'est pas libre : le non-réservé du plus haut rang cède le sien",
|
||
|
|
reservations: [resa(9, 1, 3)],
|
||
|
|
listes: [[[1, 2, 3, 4, 5, 6, 7, 9], [8, 10, 11, 12]]],
|
||
|
|
attendus: [[[1, 2, 3, 4, 5, 9], [6, 7], [6, 7]]],
|
||
|
|
},
|
||
|
|
{
|
||
|
|
nom: 'une personne réservée ne cède pas sa chaise : la personne 5 part, la 6 reste',
|
||
|
|
reservations: [resa(6, 1, null), resa(8, 1, null)],
|
||
|
|
listes: [[suite(1, 8), suite(9, 12)]],
|
||
|
|
attendus: [[[1, 2, 3, 4, 8, 6], [5, 7], [5, 7]]],
|
||
|
|
},
|
||
|
|
{
|
||
|
|
nom: "dans l'ordre des rangs : la personne 7 prend la chaise vide, la 8 celle du plus haut rang",
|
||
|
|
reservations: [resa(7, 1, null), resa(8, 1, null)],
|
||
|
|
listes: [[[1, null, 3, 4, 5, 6, 7, 8], [2, 9, 10, 11, 12]]],
|
||
|
|
attendus: [[[1, 7, 3, 4, 5, 8], [6], [6]]],
|
||
|
|
},
|
||
|
|
{
|
||
|
|
nom: 'une réservation « tour » ramène sa personne au tour 2 seulement',
|
||
|
|
reservations: [resa(8, 1, null, 2)],
|
||
|
|
listes: [
|
||
|
|
[suite(1, 8), suite(9, 12)],
|
||
|
|
[suite(1, 8), suite(9, 12)],
|
||
|
|
],
|
||
|
|
attendus: [
|
||
|
|
[suite(1, 6), [7, 8], [7, 8]],
|
||
|
|
[[1, 2, 3, 4, 5, 8], [6, 7], [6, 7]],
|
||
|
|
],
|
||
|
|
},
|
||
|
|
{
|
||
|
|
nom: 'la réservation suspendue de la personne 8, exclue, ne la ramène pas',
|
||
|
|
reservations: [resa(8, 1, null)],
|
||
|
|
exclus: [8],
|
||
|
|
listes: [[suite(1, 8), suite(9, 12)]],
|
||
|
|
attendus: [[suite(1, 6), [7, 8], [7]]],
|
||
|
|
},
|
||
|
|
];
|
||
|
|
for (const { nom, reservations, exclus = [], listes, attendus } of cas) {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, tours: listes.length, attribuerSieges: true, reservations });
|
||
|
|
placer(charge, listes, { id: 1, retenu: true });
|
||
|
|
for (const id of exclus) charge.participants[id - 1].exclu = true;
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', charge, { id: 1, sieges: 6, origine: 'champ' });
|
||
|
|
attendus.forEach(([liste, reserve], rang) => {
|
||
|
|
assert.deepEqual(apres.retenu.placement[rang].sieges[0], liste, `${nom}, tour ${rang + 1}`);
|
||
|
|
assert.deepEqual(apres.retenu.placement[rang].reserve, reserve, `${nom}, tour ${rang + 1}`);
|
||
|
|
});
|
||
|
|
const surnumeraires = attendus.map(([, , personnes], rang) => ({ code: 'SURNUMERAIRES', details: { table: 1, tour: rang + 1, personnes } }));
|
||
|
|
assert.deepEqual(avertissements, surnumeraires, nom);
|
||
|
|
assert.equal(invariantViole(apres), null, nom);
|
||
|
|
// La réduction n'ajoute aucune raison de dérive ; un exclu garde la sienne.
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), derive(charge.retenu, charge), nom);
|
||
|
|
assert.deepEqual(fautes(apres.retenu), [], nom);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
test("sièges attribués, un tour du retenu que la soirée n'a plus ramène la personne qu'une réservation « tous » tient", () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, tours: 3, attribuerSieges: true, reservations: [resa(12, 2, null)] });
|
||
|
|
placer(charge, [[suite(1, 6), suite(7, 12)], [suite(1, 6), suite(7, 12)], [suite(1, 4), suite(5, 12)]], { id: 1, retenu: true });
|
||
|
|
const deux = accepter('changerTours', charge, { tours: 2 }).charge;
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', deux, { id: 2, sieges: 6, origine: 'champ' });
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 2, tour: 3, personnes: [10, 11] } }]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[2].sieges[1], [5, 6, 7, 8, 9, 12]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[2].reserve, [10, 11]);
|
||
|
|
assert.deepEqual(fautes(apres.retenu), []);
|
||
|
|
assert.equal(invariantViole(apres), null);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('une baisse ne ramène pas la personne réservée d\'un rang au-delà de la capacité courante, que le plan ne montrait pas', () => {
|
||
|
|
// Le retenu déclare la table 1 à 10, qui n'en a plus que 8 : sièges
|
||
|
|
// attribués, la personne 9, réservée sans siège, est au rang 9.
|
||
|
|
// Sièges attribués, la réservation que le plan montrait non tenue le reste,
|
||
|
|
// et invariantViole la nomme une fois la dérive levée ; sans attribution,
|
||
|
|
// l'affichage élisait la personne 9, qui reste.
|
||
|
|
const nonTenue = { code: 'INVARIANT_VIOLE', details: { proposition: 1, violations: [{ code: 'RESERVATION', participant: 9, table: 1, tour: 1 }] } };
|
||
|
|
const cas = [
|
||
|
|
{ attribuerSieges: true, liste: suite(1, 6), reserve: [7, 8, 9, 10], personnes: [7, 8], invariant: nonTenue },
|
||
|
|
{ attribuerSieges: false, liste: [1, 2, 3, 4, 5, 9], reserve: [6, 7, 8, 10], personnes: [6, 7], invariant: null },
|
||
|
|
];
|
||
|
|
for (const { attribuerSieges, liste, reserve, personnes, invariant } of cas) {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1, sieges: 10 }, { id: 2 }], n: 12, tours: 1, attribuerSieges, reservations: [resa(9, 1, null)] });
|
||
|
|
placer(charge, [[suite(1, 10), [11, 12]]], { id: 1, retenu: true });
|
||
|
|
charge.tables[0].sieges = null;
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', charge, { id: 1, sieges: 6, origine: 'champ' });
|
||
|
|
const nom = `attribuerSieges ${attribuerSieges}`;
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].sieges[0], liste, nom);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].reserve, reserve, nom);
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 1, tour: 1, personnes } }], nom);
|
||
|
|
assert.deepEqual(etatPlaces(charge, { tour: 1 }).reserve.includes(9), attribuerSieges, nom);
|
||
|
|
assert.deepEqual(invariantViole(apres), invariant, nom);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
test('sans attribution, une liste qui dépasse encore perd ses absents, le plus petit identifiant d\'abord', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 12, tours: 1 });
|
||
|
|
placer(charge, [[suite(1, 8), suite(9, 12)]], { id: 1, retenu: true });
|
||
|
|
for (const id of [2, 3]) charge.participants[id - 1].exclu = true;
|
||
|
|
const { charge: apres, avertissements } = accepter('changerPlacesTable', charge, { id: 1, sieges: 6, origine: 'champ' });
|
||
|
|
// Six présents s'assoient ; les deux absents partent, le plus petit d'abord, jusqu'à six.
|
||
|
|
assert.deepEqual(avertissements, []);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].sieges[0], [1, 4, 5, 6, 7, 8]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[0].reserve, [2, 3]);
|
||
|
|
const sept = accepter('changerPlacesTable', charge, { id: 1, sieges: 7, origine: 'champ' }).charge;
|
||
|
|
assert.deepEqual(sept.retenu.placement[0].sieges[0], [1, 3, 4, 5, 6, 7, 8]);
|
||
|
|
assert.deepEqual(sept.retenu.placement[0].reserve, [2]);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('un compteur de tables saturé refuse COMPTEUR_SATURE ; une origine ou un réalignement de forme fausse sont des fautes du code', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }], n: 2 });
|
||
|
|
charge.prochainsIds.table = 2 ** 31 - 1;
|
||
|
|
refuse(() => COMMANDES.get('creerTable')(charge, { forme: 'ronde' }), 'COMPTEUR_SATURE', { compteur: 'table', remede: null });
|
||
|
|
assert.throws(() => COMMANDES.get('changerPlacesTable')(charge, { id: 1, sieges: 6, origine: 'clavier' }), TypeError);
|
||
|
|
assert.throws(() => COMMANDES.get('changerDefaut')(charge, { sieges: 6 }), TypeError);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('mobilier : changer le défaut (§ 6.1, § 6.2)', () => {
|
||
|
|
function treizeTables(options = {}) {
|
||
|
|
const surcharges = new Map([[3, 7], [6, 7], [9, 6], [12, 12]]);
|
||
|
|
const tables = Array.from({ length: 13 }, (_, rang) => ({ id: rang + 1, sieges: surcharges.get(rang + 1) ?? null }));
|
||
|
|
return chargeDe({ tables, n: 120, exclus: [40, 80], ...options });
|
||
|
|
}
|
||
|
|
const capacites = (charge) => charge.tables.map((table) => capacite(charge, table));
|
||
|
|
|
||
|
|
test('appliquer : les quatre surchargées gardent 7, 7, 6 et 12, les neuf autres valent 10, une entrée ; réaligner : les treize suivent 10', async () => {
|
||
|
|
const { seance, entrees } = await seanceSur(treizeTables());
|
||
|
|
const avant = entrees();
|
||
|
|
const rendu = await seance.executer('changerDefaut', { sieges: 10, realigner: false });
|
||
|
|
assert.equal(rendu.libelle, 'Sièges par défaut : 10');
|
||
|
|
assert.equal(entrees() - avant, 1);
|
||
|
|
assert.deepEqual(capacites(seance.charge), [10, 10, 7, 10, 10, 7, 10, 10, 6, 10, 10, 12, 10]);
|
||
|
|
assert.deepEqual(seance.charge.tables.filter(({ sieges }) => sieges !== null).map(({ id }) => id), [3, 6, 9, 12]);
|
||
|
|
const realigne = await seance.executer('changerDefaut', { sieges: 10, realigner: true });
|
||
|
|
assert.equal(realigne.libelle, 'Sièges par défaut : 10 ; 4 tables réalignées');
|
||
|
|
assert.equal(entrees() - avant, 2);
|
||
|
|
assert.ok(seance.charge.tables.every(({ sieges }) => sieges === null));
|
||
|
|
assert.deepEqual(capacites(seance.charge), Array(13).fill(10));
|
||
|
|
});
|
||
|
|
|
||
|
|
test('réaligner refusé en bloc : le titre du siège 12 refuse, table et remède compris, et rien ne s\'écrit ; sans réaligner, accepté', async () => {
|
||
|
|
const charge = treizeTables({ attribuerSieges: true, titres: [{ table: 12, siege: 12, libelle: 'animateur' }] });
|
||
|
|
const { seance, ecritures } = await seanceSur(charge);
|
||
|
|
const avant = ecritures();
|
||
|
|
const leve = await refuseAsync(seance.executer('changerDefaut', { sieges: 10, realigner: true }), 'SIEGES_RETIRES', {
|
||
|
|
table: 12,
|
||
|
|
sieges: [{ siege: 12, cause: 'SIEGE_TITRE', libelle: 'animateur' }],
|
||
|
|
remede: { commande: 'retirerTitre', arguments: { table: 12, siege: 12 } },
|
||
|
|
});
|
||
|
|
assert.deepEqual(leve.details.autres, []);
|
||
|
|
assert.equal(ecritures(), avant);
|
||
|
|
assert.deepEqual(capacites(seance.charge), capacites(charge));
|
||
|
|
await seance.executer('changerDefaut', { sieges: 10, realigner: false });
|
||
|
|
assert.equal(seance.charge.tables[11].sieges, 12);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('baisse refusée en bloc : la table 2 porte 7 réservations ; le défaut 6 refuse, nommant la table 2, et les trois tables restent à 8', async () => {
|
||
|
|
const reservations = suite(1, 7).map((id) => resa(id, 2, null));
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }, { id: 3 }], n: 20, reservations });
|
||
|
|
const { seance, ecritures } = await seanceSur(charge);
|
||
|
|
const avant = ecritures();
|
||
|
|
await refuseAsync(seance.executer('changerDefaut', { sieges: 6, realigner: false }), 'SOUS_RESERVATIONS', {
|
||
|
|
table: 2,
|
||
|
|
n: 7,
|
||
|
|
tour: 1,
|
||
|
|
remede: afficherTour(1),
|
||
|
|
});
|
||
|
|
assert.equal(ecritures(), avant);
|
||
|
|
assert.equal(seance.charge.evenement.siegesParDefaut, 8);
|
||
|
|
assert.deepEqual(capacites(seance.charge), [8, 8, 8]);
|
||
|
|
refuse(() => COMMANDES.get('changerDefaut')(charge, { sieges: '1', realigner: false }), 'MOINS_DE_DEUX', { remede: null });
|
||
|
|
refuse(() => COMMANDES.get('changerDefaut')(charge, { sieges: 'six', realigner: false }), 'NON_ENTIER');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('une baisse sous un retenu occupé : accepté, SURNUMERAIRES, et ces deux personnes dans la réserve du tour 2', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }, { id: 3 }], n: 18 });
|
||
|
|
placer(
|
||
|
|
charge,
|
||
|
|
[
|
||
|
|
[suite(1, 6), suite(7, 12), suite(13, 18)],
|
||
|
|
[suite(1, 5), suite(6, 10), suite(11, 18)],
|
||
|
|
],
|
||
|
|
{ id: 1, retenu: true },
|
||
|
|
);
|
||
|
|
const { charge: apres, avertissements } = accepter('changerDefaut', charge, { sieges: 6, realigner: false });
|
||
|
|
assert.deepEqual(avertissements, [{ code: 'SURNUMERAIRES', details: { table: 3, tour: 2, personnes: [17, 18] } }]);
|
||
|
|
assert.deepEqual(apres.retenu.placement[1].reserve, [17, 18]);
|
||
|
|
assert.deepEqual(apres.retenu.capacites, [6, 6, 6]);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), []);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('un défaut au-delà du seuil de lisibilité avertit une fois', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 4 });
|
||
|
|
const { avertissements } = accepter('changerDefaut', charge, { sieges: 40, realigner: false });
|
||
|
|
assert.equal(avertissements.length, 1);
|
||
|
|
assert.equal(avertissements[0].code, 'AU_DELA_LISIBLE');
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('mobilier : les tours (§ 2.1 étape 5, § 4.3)', () => {
|
||
|
|
test('R = 4 → 3 → 4 : les réservations reviennent telles quelles, et la portée « tous » ancre encore au tour 4', () => {
|
||
|
|
const debut = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 4, tours: 4, reservations: [resa(1, 2, null)] });
|
||
|
|
const trois = accepter('changerTours', debut, { tours: 3 });
|
||
|
|
assert.equal(trois.libelle, 'Nombre de tours : 3');
|
||
|
|
const quatre = accepter('changerTours', trois.charge, { tours: '4' }).charge;
|
||
|
|
assert.deepEqual(quatre.reservations, debut.reservations);
|
||
|
|
const instance = normaliser(configurationDepuisCharge(quatre));
|
||
|
|
const p = instance.indexDe.get(1);
|
||
|
|
assert.equal(instance.statut[p], STATUT.ANCRE);
|
||
|
|
assert.equal(instance.fixe[p * instance.R + 3], instance.indexTableDe.get(2));
|
||
|
|
});
|
||
|
|
|
||
|
|
test("retirer le tour 4 détruit ses réservations « tour », garde les autres, et laisse propositions et retenu en dérive", () => {
|
||
|
|
const reservations = [resa(1, 1, null, 4), resa(2, 2, null, 4), resa(3, 1, null, 2), resa(4, 2, null)];
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1, sieges: 4 }, { id: 2, sieges: 4 }], n: 8, tours: 4, reservations });
|
||
|
|
const listes = [[[1, 2, 3, 5], [4, 6, 7, 8]], [[1, 3, 5, 6], [2, 4, 7, 8]], [[1, 5, 6, 7], [2, 3, 4, 8]], [[1, 3, 5, 7], [2, 4, 6, 8]]];
|
||
|
|
placer(charge, listes, { id: 1 });
|
||
|
|
placer(charge, listes, { id: 2, retenu: true });
|
||
|
|
const { charge: apres, libelle: texte } = accepter('changerTours', charge, { tours: 3 });
|
||
|
|
assert.equal(texte, 'Nombre de tours : 3 ; 2 réservations retirées');
|
||
|
|
assert.deepEqual(apres.reservations, [resa(3, 1, null, 2), resa(4, 2, null)]);
|
||
|
|
analyser(serialiser(apres, { revision: 2, produitVersion: 'essai' }));
|
||
|
|
assert.deepEqual(apres.propositions, charge.propositions);
|
||
|
|
assert.deepEqual(apres.retenu, charge.retenu);
|
||
|
|
assert.deepEqual(derive(apres.retenu, apres), [{ code: 'TOURS_CHANGES', avant: 4, maintenant: 3 }]);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('3 → 4 : trois réservations « tour » à une table rendent B partiellement fixé ; propositions et retenu gardés, TOURS_CHANGES', () => {
|
||
|
|
const b = 5;
|
||
|
|
const reservations = [1, 2, 3].map((tour) => resa(b, 1, null, tour));
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }, { id: 2 }], n: 8, tours: 3, reservations });
|
||
|
|
const listes = [[[1, 2, 3, 5], [4, 6, 7, 8]], [[4, 5, 6, 7], [1, 2, 3, 8]], [[1, 5, 7, 8], [2, 3, 4, 6]]];
|
||
|
|
placer(charge, listes, { id: 1, retenu: true });
|
||
|
|
const avant = normaliser(configurationDepuisCharge(charge));
|
||
|
|
assert.equal(avant.statut[avant.indexDe.get(b)], STATUT.ANCRE);
|
||
|
|
const { charge: apres } = accepter('changerTours', charge, { tours: 4 });
|
||
|
|
const instance = normaliser(configurationDepuisCharge(apres));
|
||
|
|
assert.equal(instance.statut[instance.indexDe.get(b)], STATUT.PARTIELLEMENT_FIXE);
|
||
|
|
assert.deepEqual(apres.propositions, charge.propositions);
|
||
|
|
assert.deepEqual(apres.retenu, charge.retenu);
|
||
|
|
for (const placement of [apres.propositions[0], apres.retenu]) {
|
||
|
|
assert.deepEqual(derive(placement, apres), [{ code: 'TOURS_CHANGES', avant: 3, maintenant: 4 }]);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
test('« 0 » refuse MOINS_D_UN_TOUR {tours: 0}, « 2.5 » et « x » NON_ENTIER, sans écriture', async () => {
|
||
|
|
const { seance, ecritures } = await seanceSur(chargeDe({ tables: [{ id: 1 }], n: 2, tours: 2 }));
|
||
|
|
const avant = ecritures();
|
||
|
|
await refuseAsync(seance.executer('changerTours', { tours: '0' }), 'MOINS_D_UN_TOUR', { tours: 0, remede: null });
|
||
|
|
for (const tours of ['2.5', 'x']) {
|
||
|
|
await refuseAsync(seance.executer('changerTours', { tours }), 'NON_ENTIER', { saisie: tours, remede: null });
|
||
|
|
}
|
||
|
|
assert.equal(ecritures(), avant);
|
||
|
|
assert.equal(seance.charge.evenement.tours, 2);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('mobilier : les réglages (§ 5.3, § 15.4)', () => {
|
||
|
|
test('« Séparer les appartenances : désactivé », une entrée', async () => {
|
||
|
|
const { seance, entrees } = await seanceSur(chargeDe({ tables: [{ id: 1 }], n: 2 }));
|
||
|
|
const avant = entrees();
|
||
|
|
const rendu = await seance.executer('modifierReglage', { cle: 'separerAppartenances', valeur: false });
|
||
|
|
assert.equal(rendu.libelle, 'Séparer les appartenances : désactivé');
|
||
|
|
assert.equal(entrees() - avant, 1);
|
||
|
|
assert.equal(seance.charge.reglages.separerAppartenances, false);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('chaque réglage nommé se change ; une clé inconnue ou une valeur de forme fausse est une faute du code', () => {
|
||
|
|
const charge = chargeDe({ tables: [{ id: 1 }], n: 2 });
|
||
|
|
const attendus = [
|
||
|
|
['nouveauxVoisins', false, 'Nouveaux voisins à chaque tour : désactivé'],
|
||
|
|
['nouvelleTable', false, 'Nouvelle table à chaque tour : désactivé'],
|
||
|
|
['varierAppartenances', false, 'Varier les appartenances rencontrées : désactivé'],
|
||
|
|
['attribuerSieges', true, 'Attribuer les sièges : activé'],
|
||
|
|
['generation.nombre', 8, 'Propositions par génération : 8'],
|
||
|
|
['generation.arret', 300000, 'Mouvements par proposition : 300000'],
|
||
|
|
['generation.historique', 500, "Historique d'acceptation : 500"],
|
||
|
|
];
|
||
|
|
for (const [cle, valeur, texte] of attendus) {
|
||
|
|
const rendu = accepter('modifierReglage', charge, { cle, valeur });
|
||
|
|
assert.equal(rendu.libelle, texte);
|
||
|
|
const [tete, queue] = cle.split('.');
|
||
|
|
assert.equal(queue === undefined ? rendu.charge.reglages[tete] : rendu.charge.reglages[tete][queue], valeur);
|
||
|
|
}
|
||
|
|
assert.throws(() => COMMANDES.get('modifierReglage')(charge, { cle: 'couleur', valeur: true }), TypeError);
|
||
|
|
assert.throws(() => COMMANDES.get('modifierReglage')(charge, { cle: 'nouveauxVoisins', valeur: 'non' }), TypeError);
|
||
|
|
assert.throws(() => COMMANDES.get('modifierReglage')(charge, { cle: 'generation.nombre', valeur: 0 }), TypeError);
|
||
|
|
refuse(() => appliquerCommande('modifierReglage', charge, { cle: 'nouveauxVoisins', valeur: true }), 'SANS_EFFET');
|
||
|
|
});
|
||
|
|
});
|