moteurs/test/decoupage.test.mjs

// Non-régression du découpage par axe (LOT P1.0 point 4, amendé le 28/09).
//
// 1. Avec le jeu de coefficients D'ORIGINE (fixtures/coefficients-2026-05.json),
//    le pipeline complet extrait rend, sur les trois profils de référence, la
//    même sélection que selectionner() d'origine — épinglée dans
//    fixtures/sorties-origine-2026-09-28.json, générée DEPUIS le code d'astro-pro
//    (scripts/pin-origine.mjs), pas depuis ce paquet.
// 2. Chaque moteur d'axe, à budget d'axe égal, rend la sélection du mode
//    « un seul axe actif » de selectionner() d'origine (même épingle).
// 3. Avec la table HARMONISÉE, les écarts de sélection et de taux par rapport à
//    l'origine sont ceux figés dans fixtures/ecarts-harmonisation-2026-09-28.json
//    (relus par Jules avec docs/CONSTANTES.md). Les modifier = refiger sciemment.
import { test } from 'node:test'
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import { eau, energie, alimentation, integrateur, autonomie, COEFFICIENTS } from '../dist/index.js'
import { calculeEcarts } from '../scripts/ecarts-harmonisation.mjs'

const lire = (f) => JSON.parse(readFileSync(new URL(`../fixtures/${f}`, import.meta.url), 'utf8'))
const options = lire('options.json')
const postes = lire('postes.json')
const france_climat = lire('france_climat.json')
const algo_config = lire('algo-config.json')
const profils = lire('profils-reference.json')
const origine = lire('coefficients-2026-05.json')
const pin = lire('sorties-origine-2026-09-28.json')
const ecartsPin = lire('ecarts-harmonisation-2026-09-28.json')
const AXES = ['eau', 'energie', 'alim']
const MOTEURS = { eau, energie, alim: alimentation }

const resumePostes = (liste) => liste.map((p) => ({ poste_id: p.poste_id, typologie_choisie: p.typologie_choisie, dimension: p.dimension ? { valeur: p.dimension.valeur, unite: p.dimension.unite } : null, cout_eur_ht: p.cout_eur_ht, force_par_couplage: !!p.force_par_couplage }))

test('pipeline complet extrait = selectionner() d\'origine, coefficients d\'origine, trois profils', () => {
  for (const profil of profils) {
    const attendu = pin.profils[profil.nom].global
    const r = autonomie.noyau.selectionner(profil.inputs, options, postes, france_climat, { config: algo_config, coefficients: origine }, false)
    assert.equal(r.total_eur_ht, attendu.total_eur_ht, `${profil.nom} : total`)
    assert.equal(r.status, attendu.status, `${profil.nom} : statut`)
    assert.equal(r.ecart_budget_pct, attendu.ecart_budget_pct, `${profil.nom} : écart`)
    assert.deepEqual(r.couplages, attendu.couplages, `${profil.nom} : journal des couplages`)
    for (const axe of AXES) {
      assert.equal(r.axes[axe].budget_alloue, attendu.axes[axe].budget_alloue, `${profil.nom}/${axe} : budget alloué`)
      assert.equal(r.axes[axe].poids, attendu.axes[axe].poids, `${profil.nom}/${axe} : poids`)
      assert.equal(r.axes[axe].sous_total_eur_ht, attendu.axes[axe].sous_total_eur_ht, `${profil.nom}/${axe} : sous-total`)
      assert.deepEqual(resumePostes(r.axes[axe].postes), attendu.axes[axe].postes, `${profil.nom}/${axe} : postes`)
    }
  }
})

test('moteur d\'axe = mode « un seul axe actif » de selectionner() d\'origine, à budget d\'axe égal', () => {
  for (const profil of profils) {
    const contexte = autonomie.noyau.selectionner(profil.inputs, options, postes, france_climat, { config: algo_config, coefficients: origine }, false).contexte
    for (const axe of AXES) {
      const attendu = pin.profils[profil.nom].par_axe[axe]
      const r = MOTEURS[axe].calculer({ autodiag: profil.inputs, budget_axe: attendu.budget_axe, contexte }, { postes, options, algo_config, coefficients: origine })
      assert.equal(r.sorties.axe, axe)
      assert.equal(r.sorties.sous_total_eur_ht, attendu.axes[axe].sous_total_eur_ht, `${profil.nom}/${axe} : sous-total`)
      assert.equal(r.sorties.status, attendu.status, `${profil.nom}/${axe} : statut`)
      assert.deepEqual(resumePostes(r.sorties.postes), attendu.axes[axe].postes, `${profil.nom}/${axe} : postes`)
      assert.deepEqual(r.sorties.typologies, attendu.axes[axe].postes.map((p) => p.typologie_choisie))
      assert.ok(!r.avertissements.some((a) => /inter-axes/.test(a)), 'aucun couplage inter-axes dans les données')
    }
  }
})

test('intégrateur mode global = selectionner() ; mode par_axe = somme des moteurs d\'axe', () => {
  for (const profil of profils) {
    const donnees = { postes, options, algo_config, france_climat, coefficients: origine }
    const g = integrateur.calculer({ autodiag: profil.inputs, budget_total: profil.inputs.budget_eur, mode: 'global' }, donnees)
    const attendu = pin.profils[profil.nom].global
    assert.equal(g.sorties.mode, 'global')
    assert.equal(g.sorties.total_eur_ht, attendu.total_eur_ht)
    assert.equal(g.sorties.status, attendu.status)
    for (const axe of AXES) assert.deepEqual(g.sorties.axes[axe].typologies, attendu.axes[axe].postes.map((p) => p.typologie_choisie))

    const p = integrateur.calculer({ autodiag: profil.inputs, budget_total: profil.inputs.budget_eur, mode: 'par_axe' }, donnees)
    assert.equal(p.sorties.mode, 'par_axe')
    assert.deepEqual(p.sorties.budgets, g.sorties.budgets, 'même allocation de budget dans les deux modes')
    let somme = 0
    for (const axe of AXES) {
      const a = pin.profils[profil.nom].par_axe[axe]
      assert.deepEqual(p.sorties.axes[axe].typologies, a.axes[axe].postes.map((x) => x.typologie_choisie), `${profil.nom}/${axe} : par_axe = moteur d'axe`)
      somme += p.sorties.axes[axe].sous_total_eur_ht
    }
    assert.equal(p.sorties.total_eur_ht, somme)
    assert.equal(p.version, g.version)
  }
})

test('table harmonisée : écarts avec l\'origine figés (sélection et taux, trois profils)', () => {
  const { ecarts } = calculeEcarts()
  assert.deepEqual(ecarts, ecartsPin.ecarts, 'les écarts ont changé : relire docs/CONSTANTES.md puis refiger avec npm run ecarts -- --ecrire <date>')
  // Ce que l'harmonisation change sur les trois profils : aucune typologie, seulement les taux.
  assert.ok(ecarts.every((e) => e.mode.startsWith('taux')), 'sur les trois profils de référence, seule la couverture change')
  assert.notDeepEqual(COEFFICIENTS.orientation_pv.valeur, origine.orientation_pv.valeur, 'la table harmonisée diffère bien de l\'origine')
})