619 lines
28 KiB
JavaScript
619 lines
28 KiB
JavaScript
|
// © 2026 TechnoLibre (http://www.technolibre.ca)
|
|||
|
|
// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
|
|||
|
|
|
|||
|
|
// Épreuves des régions engendrées de la documentation (§ 19.8, § 19.7) : la
|
|||
|
|
// lecture des marqueurs et ses refus, le remplacement qui ne touche rien hors
|
|||
|
|
// des régions, la vérification qui nomme la région corrigée à la main, les
|
|||
|
|
// sept producteurs lus sur leur source unique, l'arbre des fichiers porteurs
|
|||
|
|
// et l'écart de version, non bloquant au cycle court et bloquant à la
|
|||
|
|
// livraison. L'arbre de test/fixtures/documentation/ porte un document aux
|
|||
|
|
// régions conformes et un manifeste inventé, sans version réelle : chaque
|
|||
|
|
// épreuve qui en a besoin l'écrit dans une copie temporaire.
|
|||
|
|
import assert from 'node:assert/strict';
|
|||
|
|
import { spawnSync } from 'node:child_process';
|
|||
|
|
import { cpSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
|
|||
|
|
import { tmpdir } from 'node:os';
|
|||
|
|
import { join } from 'node:path';
|
|||
|
|
import { fileURLToPath } from 'node:url';
|
|||
|
|
import { describe, test } from '../test/lanceur.js';
|
|||
|
|
import { versionVoisine } from '../test/version_voisine.js';
|
|||
|
|
import { creerFormat } from '../src/application/format.js';
|
|||
|
|
import { COMMANDES } from '../src/application/commandes.js';
|
|||
|
|
import { TABLES_APPLICATION, libelle } from '../src/application/libelles.js';
|
|||
|
|
import { creerTraduction } from '../src/application/traduction.js';
|
|||
|
|
import { ENTETES_DES_CHAMPS } from '../src/csv/colonnes.js';
|
|||
|
|
import { LIVREES } from '../src/demo/livrees.js';
|
|||
|
|
import { CATALOGUE } from '../src/demo/catalogue.js';
|
|||
|
|
import { CONSTANTES } from '../src/geometrie/constantes.js';
|
|||
|
|
import { REGLAGES_GENERATION } from '../src/interface/generation/reglages.js';
|
|||
|
|
import { TABLES_INTERFACE } from '../src/interface/libelles.js';
|
|||
|
|
import { RACCOURCIS } from '../src/interface/raccourcis.js';
|
|||
|
|
import { diagnostiquer } from '../src/moteur/diagnostic.js';
|
|||
|
|
import { analyser, configurationDepuisCharge } from '../src/stockage/document.js';
|
|||
|
|
import { VERSION } from '../src/version.genere.js';
|
|||
|
|
import {
|
|||
|
|
ErreurRegions,
|
|||
|
|
EXEMPLES_COMMANDES,
|
|||
|
|
PORTEURS,
|
|||
|
|
PRODUCTEURS,
|
|||
|
|
engendrerArbre,
|
|||
|
|
executer,
|
|||
|
|
lireRegions,
|
|||
|
|
producteursDe,
|
|||
|
|
remplacerRegions,
|
|||
|
|
tableau,
|
|||
|
|
tableauColonnesCsv,
|
|||
|
|
tableauCommandes,
|
|||
|
|
tableauContrastes,
|
|||
|
|
tableauDemonstrations,
|
|||
|
|
tableauRaccourcis,
|
|||
|
|
tableauReglages,
|
|||
|
|
tableauRegistre,
|
|||
|
|
verifierArbre,
|
|||
|
|
verifierRegions,
|
|||
|
|
} from './documentation.js';
|
|||
|
|
|
|||
|
|
const FIXTURE = fileURLToPath(new URL('../test/fixtures/documentation/', import.meta.url));
|
|||
|
|
const SCRIPT = fileURLToPath(new URL('./documentation.js', import.meta.url));
|
|||
|
|
const MANIFESTE = 'doc/captures/manifeste.json';
|
|||
|
|
|
|||
|
|
const { t } = creerTraduction([...TABLES_APPLICATION, ...TABLES_INTERFACE]);
|
|||
|
|
const { nombre } = creerFormat(t);
|
|||
|
|
|
|||
|
|
// Producteurs inventés, comptés : chaque appel s'inscrit dans appels.
|
|||
|
|
function producteursComptes(textes) {
|
|||
|
|
const appels = [];
|
|||
|
|
const producteurs = new Map(
|
|||
|
|
Object.entries(textes).map(([nom, texte]) => [
|
|||
|
|
nom,
|
|||
|
|
() => {
|
|||
|
|
appels.push(nom);
|
|||
|
|
return texte;
|
|||
|
|
},
|
|||
|
|
]),
|
|||
|
|
);
|
|||
|
|
return { producteurs, appels };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const debut = (nom) => `<!-- engendre:debut ${nom} -->`;
|
|||
|
|
const fin = (nom) => `<!-- engendre:fin ${nom} -->`;
|
|||
|
|
const region = (nom, contenu) => `${debut(nom)}${contenu}${fin(nom)}`;
|
|||
|
|
|
|||
|
|
// Les lignes d'un tableau Markdown, sans en-tête ni séparateur : chacune la
|
|||
|
|
// liste de ses cellules, une barre précédée d'une barre oblique inverse
|
|||
|
|
// restant dans sa cellule.
|
|||
|
|
function lignesDuTableau(texte) {
|
|||
|
|
return texte
|
|||
|
|
.split('\n')
|
|||
|
|
.slice(2)
|
|||
|
|
.map((ligne) =>
|
|||
|
|
ligne
|
|||
|
|
.slice(1, -1)
|
|||
|
|
.split(/(?<!\\)\|/)
|
|||
|
|
.map((cellule) => cellule.trim()),
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Le texte privé du contenu de ses régions : ce qui reste hors des marqueurs,
|
|||
|
|
// marqueurs compris.
|
|||
|
|
function horsRegions(texte) {
|
|||
|
|
let reste = '';
|
|||
|
|
let curseur = 0;
|
|||
|
|
for (const { debut: d, fin: f } of lireRegions(texte)) {
|
|||
|
|
reste += texte.slice(curseur, d);
|
|||
|
|
curseur = f;
|
|||
|
|
}
|
|||
|
|
return reste + texte.slice(curseur);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Une copie temporaire de l'arbre de fixture, dont chaque capture porte la
|
|||
|
|
// version donnée (aucune version n'est écrite en clair, § 18.5, point 6) ;
|
|||
|
|
// rendue avec la fonction qui l'efface.
|
|||
|
|
function copieDeLArbre(version = VERSION.affichee) {
|
|||
|
|
const racine = mkdtempSync(join(tmpdir(), 'gtt-documentation-'));
|
|||
|
|
cpSync(FIXTURE, racine, { recursive: true });
|
|||
|
|
const chemin = join(racine, MANIFESTE);
|
|||
|
|
const manifeste = JSON.parse(readFileSync(chemin, 'utf8'));
|
|||
|
|
for (const capture of manifeste.captures) capture.versionReelle = version;
|
|||
|
|
writeFileSync(chemin, `${JSON.stringify(manifeste, null, 2)}\n`);
|
|||
|
|
return { racine, effacer: () => rmSync(racine, { recursive: true, force: true }) };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function manifesteFixture() {
|
|||
|
|
return JSON.parse(readFileSync(join(FIXTURE, MANIFESTE), 'utf8'));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Une sortie qui retient ses lignes.
|
|||
|
|
function sortieRetenue() {
|
|||
|
|
const lignes = [];
|
|||
|
|
return { lignes, ecrire: (ligne) => lignes.push(ligne) };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
describe('documentation : lire les régions (§ 19.8)', () => {
|
|||
|
|
test('deux régions, dans leur ordre, chacune son nom, ses bornes et son contenu', () => {
|
|||
|
|
const texte = `Avant\n${region('reglages', '\nA\n')}\nEntre\n${region('raccourcis', '')}\nAprès\n`;
|
|||
|
|
const regions = lireRegions(texte);
|
|||
|
|
assert.deepEqual(
|
|||
|
|
regions.map(({ nom, contenu }) => ({ nom, contenu })),
|
|||
|
|
[
|
|||
|
|
{ nom: 'reglages', contenu: '\nA\n' },
|
|||
|
|
{ nom: 'raccourcis', contenu: '' },
|
|||
|
|
],
|
|||
|
|
);
|
|||
|
|
for (const { debut: d, fin: f, contenu } of regions) assert.equal(texte.slice(d, f), contenu);
|
|||
|
|
assert.deepEqual(lireRegions('Aucune région ici.\n<!-- un commentaire ordinaire -->\n'), []);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('un marqueur sans fin : échec qui nomme la région', () => {
|
|||
|
|
assert.throws(
|
|||
|
|
() => lireRegions(`${debut('reglages')}\ncontenu\n`),
|
|||
|
|
(erreur) => {
|
|||
|
|
assert.ok(erreur instanceof ErreurRegions);
|
|||
|
|
assert.deepEqual(erreur.fautes.map((f) => f.region), ['reglages']);
|
|||
|
|
assert.match(erreur.fautes[0].faute, /sans fin/);
|
|||
|
|
return true;
|
|||
|
|
},
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('une fin sans début, une région ouverte dans une autre, une fin qui en ferme une autre : échecs nommés', () => {
|
|||
|
|
const cas = [
|
|||
|
|
[`texte\n${fin('commandes')}\n`, 'commandes', /sans début/],
|
|||
|
|
[`${debut('reglages')}\n${region('commandes', '')}\n${fin('reglages')}`, 'commandes', /ouverte dans la région « reglages »/],
|
|||
|
|
[`${debut('reglages')}\n${fin('commandes')}\n`, 'commandes', /ferme la région « reglages »/],
|
|||
|
|
];
|
|||
|
|
for (const [texte, nom, motif] of cas) {
|
|||
|
|
assert.throws(
|
|||
|
|
() => lireRegions(texte),
|
|||
|
|
(erreur) => {
|
|||
|
|
assert.ok(erreur instanceof ErreurRegions, texte);
|
|||
|
|
const faute = erreur.fautes.find((f) => f.region === nom);
|
|||
|
|
assert.ok(faute !== undefined, `${texte} : ${JSON.stringify(erreur.fautes)}`);
|
|||
|
|
assert.match(faute.faute, motif);
|
|||
|
|
return true;
|
|||
|
|
},
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('une région en double : échec qui la nomme', () => {
|
|||
|
|
assert.throws(
|
|||
|
|
() => lireRegions(`${region('raccourcis', '\n')}\n${region('raccourcis', '\n')}\n`),
|
|||
|
|
(erreur) => {
|
|||
|
|
assert.ok(erreur instanceof ErreurRegions);
|
|||
|
|
assert.deepEqual(erreur.fautes.map((f) => [f.region, /en double/.test(f.faute)]), [['raccourcis', true]]);
|
|||
|
|
return true;
|
|||
|
|
},
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('un marqueur illisible — sans nom, nom en capitales, mot inconnu, commentaire jamais fermé — est un échec, jamais un texte ordinaire', () => {
|
|||
|
|
for (const marqueur of [
|
|||
|
|
'<!-- engendre:debut -->',
|
|||
|
|
'<!-- engendre:debut Reglages -->',
|
|||
|
|
'<!-- engendre:milieu reglages -->',
|
|||
|
|
'<!-- engendre:debut reglages',
|
|||
|
|
]) {
|
|||
|
|
assert.throws(
|
|||
|
|
() => lireRegions(`Avant\n${marqueur}\nAprès\n`),
|
|||
|
|
(erreur) => {
|
|||
|
|
assert.ok(erreur instanceof ErreurRegions, marqueur);
|
|||
|
|
assert.match(erreur.fautes[0].faute, /marqueur illisible/);
|
|||
|
|
return true;
|
|||
|
|
},
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
describe('documentation : remplacer les régions (§ 19.8)', () => {
|
|||
|
|
test('chaque région reçoit ce que son producteur rend, entre deux lignes vides ; un second passage ne change rien', () => {
|
|||
|
|
const { producteurs } = producteursComptes({ reglages: '| a |\n|---|\n| 1 |', raccourcis: 'Texte\n' });
|
|||
|
|
const texte = `# Titre\n\n${region('reglages', '\nancien\n')}\n\n${region('raccourcis', '')}\n`;
|
|||
|
|
const rendu = remplacerRegions(texte, producteurs);
|
|||
|
|
assert.equal(
|
|||
|
|
rendu,
|
|||
|
|
`# Titre\n\n${region('reglages', '\n\n| a |\n|---|\n| 1 |\n\n')}\n\n${region('raccourcis', '\n\nTexte\n\n')}\n`,
|
|||
|
|
);
|
|||
|
|
assert.equal(remplacerRegions(rendu, producteurs), rendu);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("rien ne change hors des marqueurs : marque d'ordre, fins de ligne CRLF, espaces de fin, tabulations, espace insécable, caractère astral", () => {
|
|||
|
|
const { producteurs } = producteursComptes({ commandes: 'neuf' });
|
|||
|
|
const avant = `\u{FEFF}Titre\r\nligne \r\n\tretrait\u{A0}fin \u{1F600}\r\n${region('commandes', 'ancien\r\n')}\r\nqueue\t \r\n`;
|
|||
|
|
const apres = remplacerRegions(avant, producteurs);
|
|||
|
|
assert.notEqual(apres, avant);
|
|||
|
|
assert.equal(Buffer.compare(Buffer.from(horsRegions(apres)), Buffer.from(horsRegions(avant))), 0);
|
|||
|
|
const [{ debut: d }] = lireRegions(avant);
|
|||
|
|
assert.equal(apres.slice(0, d), avant.slice(0, d));
|
|||
|
|
assert.ok(apres.endsWith(`${fin('commandes')}\r\nqueue\t \r\n`));
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('un nom inconnu lève en le nommant, sans rien rendre', () => {
|
|||
|
|
const { producteurs, appels } = producteursComptes({ reglages: 'x' });
|
|||
|
|
assert.throws(
|
|||
|
|
() => remplacerRegions(`${region('reglages', '')}\n${region('inconnue', '')}\n`, producteurs),
|
|||
|
|
(erreur) => {
|
|||
|
|
assert.ok(erreur instanceof ErreurRegions);
|
|||
|
|
assert.deepEqual(erreur.fautes.map((f) => f.region), ['inconnue']);
|
|||
|
|
assert.match(erreur.fautes[0].faute, /nom inconnu/);
|
|||
|
|
return true;
|
|||
|
|
},
|
|||
|
|
);
|
|||
|
|
assert.deepEqual(appels, []);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('un texte sans région se rend tel quel', () => {
|
|||
|
|
const { producteurs, appels } = producteursComptes({ reglages: 'x' });
|
|||
|
|
assert.equal(remplacerRegions('Rien à engendrer.\n', producteurs), 'Rien à engendrer.\n');
|
|||
|
|
assert.deepEqual(appels, []);
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
describe('documentation : vérifier les régions (§ 19.8, § 14.3)', () => {
|
|||
|
|
const { producteurs } = producteursComptes({ reglages: 'R', raccourcis: 'K' });
|
|||
|
|
const conforme = remplacerRegions(`${region('reglages', '')}\n\n${region('raccourcis', '')}\n`, producteurs);
|
|||
|
|
|
|||
|
|
test('des régions conformes : aucune faute', () => {
|
|||
|
|
assert.deepEqual(verifierRegions(conforme, producteurs), []);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('une correction à la main dans une région : une faute, qui nomme cette région seule', () => {
|
|||
|
|
const corrige = conforme.replace('\n\nK\n\n', '\n\nK corrigé à la main\n\n');
|
|||
|
|
assert.notEqual(corrige, conforme);
|
|||
|
|
const fautes = verifierRegions(corrige, producteurs);
|
|||
|
|
assert.deepEqual(fautes.map((f) => f.region), ['raccourcis']);
|
|||
|
|
assert.match(fautes[0].faute, /diffère de ce que le producteur engendre/);
|
|||
|
|
assert.match(fautes[0].faute, /K corrigé à la main/);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('un nom inconnu, une région en double, un marqueur sans fin : des fautes, pas une exception', () => {
|
|||
|
|
assert.deepEqual(
|
|||
|
|
verifierRegions(`${conforme}${region('inconnue', '')}\n`, producteurs).map((f) => [f.region, /nom inconnu/.test(f.faute)]),
|
|||
|
|
[['inconnue', true]],
|
|||
|
|
);
|
|||
|
|
assert.deepEqual(
|
|||
|
|
verifierRegions(`${conforme}${region('reglages', '\n\nR\n\n')}\n`, producteurs).map((f) => f.region),
|
|||
|
|
['reglages'],
|
|||
|
|
);
|
|||
|
|
assert.match(verifierRegions(`${conforme}${debut('reglages')}\n`, producteurs)[0].faute, /sans fin/);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('zéro région : une faute, un balayage vide ne passe pas (§ 14.2)', () => {
|
|||
|
|
const fautes = verifierRegions('Un document sans marqueur.\n', producteurs);
|
|||
|
|
assert.equal(fautes.length, 1);
|
|||
|
|
assert.equal(fautes[0].region, null);
|
|||
|
|
assert.match(fautes[0].faute, /aucune région/);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("un producteur qui lève : une faute qui nomme sa région et l'erreur", () => {
|
|||
|
|
const enPanne = new Map([['reglages', () => { throw new Error('source illisible'); }]]);
|
|||
|
|
const fautes = verifierRegions(`${region('reglages', '')}\n`, enPanne);
|
|||
|
|
assert.deepEqual(fautes.map((f) => f.region), ['reglages']);
|
|||
|
|
assert.match(fautes[0].faute, /source illisible/);
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
describe('documentation : les producteurs, chacun sur sa source unique (§ 19.8)', () => {
|
|||
|
|
test('les sept producteurs, dans leur ordre ; PORTEURS est une liste figée', () => {
|
|||
|
|
assert.deepEqual(
|
|||
|
|
PRODUCTEURS.map(({ nom }) => nom),
|
|||
|
|
['reglages', 'colonnes-csv', 'commandes', 'raccourcis', 'demonstrations', 'contrastes', 'constantes'],
|
|||
|
|
);
|
|||
|
|
assert.ok(Object.isFrozen(PRODUCTEURS) && Object.isFrozen(PORTEURS));
|
|||
|
|
assert.deepEqual([...producteursDe({ manifeste: () => null }).keys()], PRODUCTEURS.map(({ nom }) => nom));
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("tableau : une ligne d'en-tête, un séparateur, une ligne par entrée ; une barre et un saut de ligne ne cassent pas la cellule", () => {
|
|||
|
|
assert.equal(
|
|||
|
|
tableau(['A', 'B'], [['x | y', 'deux\nlignes']]),
|
|||
|
|
'| A | B |\n|---|---|\n| x \\| y | deux lignes |',
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('reglages : une ligne par entrée de la définition, son libellé, son écran et son défaut ; une entrée ajoutée paraît', () => {
|
|||
|
|
const lignes = lignesDuTableau(tableauReglages());
|
|||
|
|
assert.equal(lignes.length, REGLAGES_GENERATION.length);
|
|||
|
|
REGLAGES_GENERATION.forEach((entree, rang) => {
|
|||
|
|
const attendu = entree.genre === 'champ' ? nombre(entree.defaut) : entree.defaut ? 'cochée' : 'décochée';
|
|||
|
|
assert.deepEqual(lignes[rang], [t(entree.etiquette), t(`coquille.section.${entree.section}`), attendu]);
|
|||
|
|
});
|
|||
|
|
const ajoutee = { ...REGLAGES_GENERATION[0], etiquette: 'generation.reglage.graine', defaut: 4_294_967_295 };
|
|||
|
|
const avecAjout = lignesDuTableau(tableauReglages([...REGLAGES_GENERATION, ajoutee]));
|
|||
|
|
assert.deepEqual(avecAjout.at(-1), [t('generation.reglage.graine'), t('coquille.section.generation'), '4\u{202F}294\u{202F}967\u{202F}295']);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('colonnes-csv : une ligne par champ, son en-tête puis ses synonymes, rien de plus', () => {
|
|||
|
|
const lignes = lignesDuTableau(tableauColonnesCsv());
|
|||
|
|
assert.deepEqual(
|
|||
|
|
lignes,
|
|||
|
|
ENTETES_DES_CHAMPS.map(([, [entete, ...synonymes]]) => [
|
|||
|
|
`\`${entete}\``,
|
|||
|
|
synonymes.length === 0 ? t('format.vide') : synonymes.map((s) => `\`${s}\``).join(', '),
|
|||
|
|
]),
|
|||
|
|
);
|
|||
|
|
assert.deepEqual(lignes.find(([c]) => c === '`titre_pressenti`'), ['`titre_pressenti`', '`titre`, `rôle`']);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("commandes : une ligne par commande du registre, dans son ordre, et son libellé d'historique composé par la traduction", () => {
|
|||
|
|
const lignes = lignesDuTableau(tableauCommandes());
|
|||
|
|
assert.deepEqual(lignes.map(([nom]) => nom), [...COMMANDES.keys()].map((nom) => `\`${nom}\``));
|
|||
|
|
for (const [cellule, exemple] of lignes) {
|
|||
|
|
const nom = cellule.slice(1, -1);
|
|||
|
|
const cle = `ENTREE_${nom.replace(/[A-Z]/g, (lettre) => `_${lettre}`).toUpperCase()}`;
|
|||
|
|
assert.equal(exemple, libelle(cle, EXEMPLES_COMMANDES[nom]), nom);
|
|||
|
|
}
|
|||
|
|
assert.ok(lignes.some(([, exemple]) => exemple === 'Ajouté Iris Ombrelle'));
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("commandes : une commande sans exemple, ou sans libellé d'historique, lève en la nommant", () => {
|
|||
|
|
const avecNouvelle = new Map([...COMMANDES, ['commandeInventee', () => null]]);
|
|||
|
|
assert.throws(() => tableauCommandes(avecNouvelle), /commandeInventee/);
|
|||
|
|
assert.throws(
|
|||
|
|
() => tableauCommandes(avecNouvelle, { ...EXEMPLES_COMMANDES, commandeInventee: {} }),
|
|||
|
|
/ENTREE_COMMANDE_INVENTEE/,
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('raccourcis : une ligne par contexte et par effet, ses touches nommées, son libellé ; chaque entrée de la table y est', () => {
|
|||
|
|
const lignes = lignesDuTableau(tableauRaccourcis());
|
|||
|
|
const effets = [...new Set(RACCOURCIS.map(({ contexte, effet }) => `${contexte}.${effet}`))];
|
|||
|
|
assert.equal(lignes.length, effets.length);
|
|||
|
|
lignes.forEach(([, , texte], rang) => assert.equal(texte, t(`raccourcis.${effets[rang]}`)));
|
|||
|
|
const entrer = lignes[effets.indexOf('plan.entrer')];
|
|||
|
|
assert.equal(entrer[1], 'Entrée ou Espace');
|
|||
|
|
assert.equal(lignes[effets.indexOf('plan.droite')][1], '\u{2192}');
|
|||
|
|
assert.equal(lignes[effets.indexOf('grille.precedente')][1], 'Maj+Tab');
|
|||
|
|
assert.throws(() => tableauRaccourcis([...RACCOURCIS, { ...RACCOURCIS[0], touche: 'Pause' }]), /Pause/);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('demonstrations : effectif, tables, tours et plafond a priori égaux à diagnostiquer sur chaque fichier livré', () => {
|
|||
|
|
const lignes = lignesDuTableau(tableauDemonstrations());
|
|||
|
|
assert.equal(lignes.length, LIVREES.length);
|
|||
|
|
LIVREES.forEach(({ cle, texte }, rang) => {
|
|||
|
|
const configuration = configurationDepuisCharge(analyser(texte).charge);
|
|||
|
|
const { plafondAPriori } = diagnostiquer(configuration);
|
|||
|
|
assert.deepEqual(lignes[rang], [
|
|||
|
|
CATALOGUE.find((entree) => entree.cle === cle).nom,
|
|||
|
|
nombre(configuration.participants.length),
|
|||
|
|
nombre(configuration.tables.length),
|
|||
|
|
nombre(configuration.tours),
|
|||
|
|
nombre(plafondAPriori.min),
|
|||
|
|
nombre(plafondAPriori.max),
|
|||
|
|
]);
|
|||
|
|
});
|
|||
|
|
assert.deepEqual(lignes[0].slice(1), ['260', '33', '4', '24', '28']);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("contrastes : par jeton et rôle, le plus petit ratio de chaque thème et la première capture où il l'est", () => {
|
|||
|
|
assert.deepEqual(lignesDuTableau(tableauContrastes(manifesteFixture())), [
|
|||
|
|
['`encre`', 'marque', '3', t('format.vide'), t('format.vide'), '5,50', '02-import-apercu'],
|
|||
|
|
['`encre`', 'texte', '4,5', '9,81', '02-import-apercu', '11,20', '01-premier-ecran'],
|
|||
|
|
['`encre-douce`', 'texte', '4,5', '5,20', '01-premier-ecran', '4,62', '02-import-apercu'],
|
|||
|
|
['`focus`', 'marque', '3', '3,40', '01-premier-ecran', '3,90', '02-import-apercu'],
|
|||
|
|
]);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('contrastes : un style sans jeton, ou deux seuils pour un même rôle, lèvent ; aucun style relevé lève', () => {
|
|||
|
|
const sansJeton = manifesteFixture();
|
|||
|
|
delete sansJeton.captures[1].styles.sombre[0].jeton;
|
|||
|
|
assert.throws(() => tableauContrastes(sansJeton), /02-import-apercu/);
|
|||
|
|
const deuxSeuils = manifesteFixture();
|
|||
|
|
deuxSeuils.captures[1].styles.clair[0].seuil = 3;
|
|||
|
|
assert.throws(() => tableauContrastes(deuxSeuils), /seuil/);
|
|||
|
|
const vide = manifesteFixture();
|
|||
|
|
for (const capture of vide.captures) capture.styles = { clair: [], sombre: [] };
|
|||
|
|
assert.throws(() => tableauContrastes(vide), /aucun style/);
|
|||
|
|
assert.throws(() => tableauContrastes(null), /manifeste/);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('constantes : une ligne par constante du registre, sa valeur, son unité, son propriétaire, son statut en toutes lettres et son protocole', () => {
|
|||
|
|
const lignes = lignesDuTableau(tableauRegistre());
|
|||
|
|
assert.equal(lignes.length, CONSTANTES.length);
|
|||
|
|
CONSTANTES.forEach((c, rang) => {
|
|||
|
|
assert.equal(lignes[rang][0], `\`${c.nom}\``);
|
|||
|
|
assert.equal(lignes[rang][2], c.unite);
|
|||
|
|
assert.equal(lignes[rang][3], c.proprietaire);
|
|||
|
|
assert.equal(lignes[rang][4], c.statut === 'mesuree' ? 'mesurée' : 'défaut de travail');
|
|||
|
|
assert.equal(lignes[rang][5].replace(/\\\|/g, '|'), c.protocole.replace(/\s*\n\s*/g, ' '));
|
|||
|
|
});
|
|||
|
|
const inventees = [
|
|||
|
|
{ ...CONSTANTES[0], nom: 'A', valeur: 0.3, statut: 'mesuree' },
|
|||
|
|
{ ...CONSTANTES[0], nom: 'B', valeur: null },
|
|||
|
|
{ ...CONSTANTES[0], nom: 'C', valeur: 200_000 },
|
|||
|
|
];
|
|||
|
|
assert.deepEqual(
|
|||
|
|
lignesDuTableau(tableauRegistre(inventees)).map((l) => [l[1], l[4]]),
|
|||
|
|
[['0,3', 'mesurée'], [t('format.vide'), 'défaut de travail'], ['200\u{202F}000', 'défaut de travail']],
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
describe("documentation : l'arbre des porteurs et l'écart de version (§ 19.7, § 19.8)", () => {
|
|||
|
|
test("l'arbre de fixture, à la version de la construction : conforme, code zéro, livraison comprise", () => {
|
|||
|
|
const { racine, effacer } = copieDeLArbre();
|
|||
|
|
try {
|
|||
|
|
for (const livraison of [false, true]) {
|
|||
|
|
const bilan = verifierArbre({ racine, porteurs: ['README.md'], livraison });
|
|||
|
|
assert.deepEqual(bilan.fautes, []);
|
|||
|
|
assert.equal(bilan.ecart, null);
|
|||
|
|
assert.equal(bilan.code, 0);
|
|||
|
|
}
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("seul l'écart de version change le code de sortie : affiché sans --livraison, bloquant avec", () => {
|
|||
|
|
const voisine = versionVoisine(VERSION.affichee);
|
|||
|
|
const { racine, effacer } = copieDeLArbre(voisine);
|
|||
|
|
try {
|
|||
|
|
const court = verifierArbre({ racine, porteurs: ['README.md'], livraison: false });
|
|||
|
|
const livraison = verifierArbre({ racine, porteurs: ['README.md'], livraison: true });
|
|||
|
|
assert.deepEqual(court.ecart, { manifeste: voisine, construction: VERSION.affichee });
|
|||
|
|
assert.deepEqual(livraison.ecart, court.ecart);
|
|||
|
|
assert.deepEqual([court.fautes, livraison.fautes], [[], []]);
|
|||
|
|
assert.deepEqual([court.code, livraison.code], [0, 1]);
|
|||
|
|
const sortie = sortieRetenue();
|
|||
|
|
assert.equal(executer(['verifier', '--racine', racine, '--porteur', 'README.md'], { sortie: sortie.ecrire }), 0);
|
|||
|
|
assert.ok(sortie.lignes.some((l) => /écart de version \(non bloquant\)/.test(l) && l.includes(voisine)), sortie.lignes.join('\n'));
|
|||
|
|
const bloquee = sortieRetenue();
|
|||
|
|
assert.equal(executer(['verifier', '--livraison', '--racine', racine, '--porteur', 'README.md'], { sortie: bloquee.ecrire }), 1);
|
|||
|
|
assert.ok(bloquee.lignes.some((l) => /écart de version \(bloquant\)/.test(l)), bloquee.lignes.join('\n'));
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('la ligne de commande, en processus : --livraison sort non nul pour le seul écart, zéro sans lui', () => {
|
|||
|
|
const lancer = (racine, ...options) =>
|
|||
|
|
spawnSync(process.execPath, [SCRIPT, 'verifier', ...options, '--racine', racine, '--porteur', 'README.md'], { encoding: 'utf8' });
|
|||
|
|
const avecEcart = copieDeLArbre(versionVoisine(VERSION.affichee));
|
|||
|
|
const sansEcart = copieDeLArbre();
|
|||
|
|
try {
|
|||
|
|
assert.equal(lancer(avecEcart.racine, '--livraison').status, 1);
|
|||
|
|
assert.equal(lancer(avecEcart.racine).status, 0);
|
|||
|
|
const conforme = lancer(sansEcart.racine, '--livraison');
|
|||
|
|
assert.equal(conforme.status, 0, conforme.stdout + conforme.stderr);
|
|||
|
|
assert.equal(spawnSync(process.execPath, [SCRIPT, 'publier'], { encoding: 'utf8' }).status, 2);
|
|||
|
|
} finally {
|
|||
|
|
avecEcart.effacer();
|
|||
|
|
sansEcart.effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("un manifeste absent est un écart : l'arbre ne prouve aucune version", () => {
|
|||
|
|
const { racine, effacer } = copieDeLArbre();
|
|||
|
|
try {
|
|||
|
|
rmSync(join(racine, MANIFESTE));
|
|||
|
|
writeFileSync(join(racine, 'SANS-CONTRASTES.md'), `${region('colonnes-csv', `\n\n${tableauColonnesCsv()}\n\n`)}\n`);
|
|||
|
|
const bilan = verifierArbre({ racine, porteurs: ['SANS-CONTRASTES.md'], livraison: true });
|
|||
|
|
assert.deepEqual(bilan.fautes, []);
|
|||
|
|
assert.deepEqual(bilan.ecart, { manifeste: null, construction: VERSION.affichee });
|
|||
|
|
assert.equal(bilan.code, 1);
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("un fichier hors de PORTEURS n'est pas lu : seuls le porteur et le manifeste le sont", () => {
|
|||
|
|
const { racine, effacer } = copieDeLArbre();
|
|||
|
|
try {
|
|||
|
|
const lus = [];
|
|||
|
|
const lire = (chemin) => {
|
|||
|
|
lus.push(chemin);
|
|||
|
|
return readFileSync(join(racine, chemin), 'utf8');
|
|||
|
|
};
|
|||
|
|
assert.equal(verifierArbre({ racine, porteurs: ['README.md'], lire }).code, 0);
|
|||
|
|
assert.deepEqual(lus, ['README.md', MANIFESTE]);
|
|||
|
|
const avecHors = verifierArbre({ racine, porteurs: ['README.md', 'HORS-PORTEURS.md'] });
|
|||
|
|
assert.deepEqual(avecHors.fautes.map((f) => f.chemin), ['HORS-PORTEURS.md']);
|
|||
|
|
assert.match(avecHors.fautes[0].faute, /sans fin/);
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('zéro région dans un porteur, un porteur absent, aucun porteur : des fautes, code non nul', () => {
|
|||
|
|
const { racine, effacer } = copieDeLArbre();
|
|||
|
|
try {
|
|||
|
|
writeFileSync(join(racine, 'VIDE.md'), '# Rien\n');
|
|||
|
|
const bilan = verifierArbre({ racine, porteurs: ['README.md', 'VIDE.md', 'ABSENT.md'] });
|
|||
|
|
assert.deepEqual(bilan.fautes.map((f) => f.chemin), ['VIDE.md', 'ABSENT.md']);
|
|||
|
|
assert.match(bilan.fautes[0].faute, /aucune région/);
|
|||
|
|
assert.match(bilan.fautes[1].faute, /absent/);
|
|||
|
|
assert.equal(bilan.code, 1);
|
|||
|
|
const sansPorteur = verifierArbre({ racine, porteurs: [] });
|
|||
|
|
assert.equal(sansPorteur.code, 1);
|
|||
|
|
assert.match(sansPorteur.fautes[0].faute, /aucun fichier porteur/);
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("sans liste donnée, verifier, engendrer et la ligne de commande s'en tiennent à PORTEURS : mêmes lectures, mêmes écritures, même bilan qu'avec PORTEURS en clair", () => {
|
|||
|
|
const { racine, effacer } = copieDeLArbre();
|
|||
|
|
// Un lancement espionné : ce qu'il lit, ce qu'il écrirait, ce qu'il
|
|||
|
|
// affiche et ce qu'il rend, la liste de porteurs donnée ou non.
|
|||
|
|
const espionne = (lancer, options) => {
|
|||
|
|
const lus = [];
|
|||
|
|
const ecrits = [];
|
|||
|
|
const sortie = sortieRetenue();
|
|||
|
|
const lire = (chemin) => {
|
|||
|
|
lus.push(chemin);
|
|||
|
|
return readFileSync(join(racine, chemin), 'utf8');
|
|||
|
|
};
|
|||
|
|
const rendu = lancer({ ...options, lire, ecrire: (chemin) => ecrits.push(chemin), sortie: sortie.ecrire });
|
|||
|
|
return { rendu, lus, ecrits, lignes: sortie.lignes };
|
|||
|
|
};
|
|||
|
|
const lanceurs = [
|
|||
|
|
['verifierArbre', (options) => verifierArbre({ racine, ...options })],
|
|||
|
|
['engendrerArbre', (options) => engendrerArbre({ racine, ...options })],
|
|||
|
|
['executer verifier', (options) => executer(['verifier', '--racine', racine], options)],
|
|||
|
|
['executer engendrer', (options) => executer(['engendrer', '--racine', racine], options)],
|
|||
|
|
];
|
|||
|
|
try {
|
|||
|
|
for (const [nom, lancer] of lanceurs) {
|
|||
|
|
const implicite = espionne(lancer, {});
|
|||
|
|
assert.deepEqual(implicite, espionne(lancer, { porteurs: PORTEURS }), nom);
|
|||
|
|
assert.deepEqual(implicite.lus.filter((chemin) => chemin !== MANIFESTE), [...PORTEURS], nom);
|
|||
|
|
}
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test('engendrer réécrit les seules régions, octets du reste identiques ; vérifier passe ensuite, et un second passage n’écrit rien', () => {
|
|||
|
|
const { racine, effacer } = copieDeLArbre();
|
|||
|
|
try {
|
|||
|
|
const noms = PRODUCTEURS.map(({ nom }) => nom);
|
|||
|
|
const avant = `\u{FEFF}# Annexe\r\n\r\n${noms.map((nom) => `## ${nom} \r\n${region(nom, '\nà refaire\n')}\r\n`).join('\t\r\n')}fin\u{A0}\r\n`;
|
|||
|
|
writeFileSync(join(racine, 'ANNEXE.md'), avant);
|
|||
|
|
const porteurs = ['README.md', 'ANNEXE.md'];
|
|||
|
|
assert.notEqual(verifierArbre({ racine, porteurs }).code, 0);
|
|||
|
|
const premier = engendrerArbre({ racine, porteurs });
|
|||
|
|
assert.deepEqual([premier.fautes, premier.ecrits, premier.code], [[], ['ANNEXE.md'], 0]);
|
|||
|
|
const apres = readFileSync(join(racine, 'ANNEXE.md'), 'utf8');
|
|||
|
|
assert.equal(Buffer.compare(Buffer.from(horsRegions(apres)), Buffer.from(horsRegions(avant))), 0);
|
|||
|
|
assert.deepEqual(lireRegions(apres).map((r) => r.nom), noms);
|
|||
|
|
assert.deepEqual(verifierArbre({ racine, porteurs, livraison: true }).code, 0);
|
|||
|
|
assert.deepEqual(engendrerArbre({ racine, porteurs }).ecrits, []);
|
|||
|
|
assert.equal(readFileSync(join(racine, 'README.md'), 'utf8'), readFileSync(join(FIXTURE, 'README.md'), 'utf8'));
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("engendrer n'écrit rien quand un porteur est en faute", () => {
|
|||
|
|
const { racine, effacer } = copieDeLArbre();
|
|||
|
|
try {
|
|||
|
|
writeFileSync(join(racine, 'A.md'), `${region('reglages', '')}\n`);
|
|||
|
|
writeFileSync(join(racine, 'B.md'), `${debut('commandes')}\n`);
|
|||
|
|
const ecrits = [];
|
|||
|
|
const bilan = engendrerArbre({ racine, porteurs: ['A.md', 'B.md'], ecrire: (chemin) => ecrits.push(chemin) });
|
|||
|
|
assert.equal(bilan.code, 1);
|
|||
|
|
assert.deepEqual(bilan.fautes.map((f) => f.chemin), ['B.md']);
|
|||
|
|
assert.deepEqual([bilan.ecrits, ecrits], [[], []]);
|
|||
|
|
assert.equal(readFileSync(join(racine, 'A.md'), 'utf8'), `${region('reglages', '')}\n`);
|
|||
|
|
} finally {
|
|||
|
|
effacer();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("le README de l'arbre de fixture est tel qu'engendré : sa région de contrastes est celle du manifeste de fixture", () => {
|
|||
|
|
const [{ nom, contenu }] = lireRegions(readFileSync(join(FIXTURE, 'README.md'), 'utf8'));
|
|||
|
|
assert.equal(nom, 'contrastes');
|
|||
|
|
assert.equal(contenu, `\n\n${tableauContrastes(manifesteFixture())}\n\n`);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
test("la ligne de commande refuse un mode inconnu, --livraison hors de verifier et une option sans valeur, code 2, sans rien lire", () => {
|
|||
|
|
for (const argv of [[], ['publier'], ['engendrer', '--livraison'], ['verifier', '--racine'], ['verifier', '--inconnue']]) {
|
|||
|
|
const sortie = sortieRetenue();
|
|||
|
|
const lus = [];
|
|||
|
|
assert.equal(executer(argv, { sortie: sortie.ecrire, lire: (chemin) => lus.push(chemin) }), 2, argv.join(' '));
|
|||
|
|
assert.deepEqual(lus, []);
|
|||
|
|
assert.ok(sortie.lignes.some((l) => /engendrer \| verifier/.test(l)), argv.join(' '));
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
});
|