forked from yvv/decision
v2 : moteurs purs complets + ambiances + persistance + seed Atelier du Canal
- engine/ : parametric (médiane basse, cristallisation, impact linear-share, bimodalité), state (canTransition 9 gardes doctrinales + windowOutcome), settings (resolveSettings + replis), triage (R-U→R6, phrases françaises), impact (concernés calculés), électionResult (blanc, quorum, égalité sans départage machine) — 296 tests vitest verts - moods.css v2 : Source/Margelle/Nappe/Minuit (champ lexical du puits), tokens routes/états, socle borderless, print A4, tampon 井 - data/persistence.ts : IndexedDB local-first, export/import Bundle, lignée - Seed Atelier du Canal (145 Ko, tous les états de l'UI) + test - backend/scripts/export_seed_bundle.py (extraction Ğ1, bundle à générer) - test anti-lexique (marqueur ld-v2) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Yvv
@@ -0,0 +1,168 @@
|
||||
/**
|
||||
* electionResult — simple plurality (BLUEPRINT-V2.md Δ28, « Modalités » #4).
|
||||
*
|
||||
* Contract under test: the caller passes the LAST ACTIVE votes only
|
||||
* (supersedesVoteId chains resolved by the store) — one vote per voter.
|
||||
* Blank vote = no choicePersonId: counts for participation, never for
|
||||
* designation. The engine NEVER breaks a tie.
|
||||
*/
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import type { Vote } from '../../app/types/domain'
|
||||
import { electionResult } from '../../app/engine/threshold'
|
||||
|
||||
let seq = 0
|
||||
|
||||
/** Build a minimal last-active Vote; omit choicePersonId for a blank. */
|
||||
function vote(choicePersonId?: string): Vote {
|
||||
seq++
|
||||
return {
|
||||
id: `vote-${seq}`,
|
||||
collectiveId: 'col-1',
|
||||
createdAt: '2026-08-11T00:00:00Z',
|
||||
updatedAt: '2026-08-11T00:00:00Z',
|
||||
sessionId: 'session-1',
|
||||
voterId: `voter-${seq}`,
|
||||
choicePersonId,
|
||||
}
|
||||
}
|
||||
|
||||
/** n votes for the same person (or n blanks when personId is undefined). */
|
||||
function votes(n: number, personId?: string): Vote[] {
|
||||
return Array.from({ length: n }, () => vote(personId))
|
||||
}
|
||||
|
||||
describe('electionResult — clear plurality', () => {
|
||||
it('elects the most designated person; blanks count in participation only', () => {
|
||||
const ballot = [...votes(3, 'alice'), ...votes(2, 'bob'), ...votes(1)]
|
||||
const result = electionResult(ballot, { electionMinParticipants: 5 })
|
||||
|
||||
expect(result).toEqual({
|
||||
outcome: 'elected',
|
||||
winnerId: 'alice',
|
||||
counts: { alice: 3, bob: 2 },
|
||||
blanks: 1,
|
||||
participants: 6,
|
||||
})
|
||||
})
|
||||
|
||||
it('a tie below the top does not prevent election', () => {
|
||||
const ballot = [...votes(3, 'alice'), ...votes(2, 'bob'), ...votes(2, 'carol')]
|
||||
const result = electionResult(ballot, {})
|
||||
|
||||
expect(result.outcome).toBe('elected')
|
||||
if (result.outcome === 'elected') {
|
||||
expect(result.winnerId).toBe('alice')
|
||||
expect(result.counts).toEqual({ alice: 3, bob: 2, carol: 2 })
|
||||
}
|
||||
})
|
||||
|
||||
it('works without any quorum configured (electionMinParticipants undefined)', () => {
|
||||
const result = electionResult([vote('alice')], {})
|
||||
expect(result.outcome).toBe('elected')
|
||||
})
|
||||
})
|
||||
|
||||
describe('electionResult — tie: the engine NEVER breaks it', () => {
|
||||
it('two-way tie at the top => tie with sorted exAequoIds', () => {
|
||||
const ballot = [...votes(2, 'bob'), ...votes(2, 'alice'), ...votes(1, 'carol')]
|
||||
const result = electionResult(ballot, { electionMinParticipants: 3 })
|
||||
|
||||
expect(result).toEqual({
|
||||
outcome: 'tie',
|
||||
exAequoIds: ['alice', 'bob'], // sorted — deterministic order, not a tie-break
|
||||
counts: { alice: 2, bob: 2, carol: 1 },
|
||||
blanks: 0,
|
||||
participants: 5,
|
||||
})
|
||||
})
|
||||
|
||||
it('three-way tie => all three ex aequo, sorted regardless of arrival order', () => {
|
||||
const ballot = [...votes(2, 'carol'), ...votes(2, 'alice'), ...votes(2, 'bob'), ...votes(1)]
|
||||
const result = electionResult(ballot, { electionMinParticipants: 4 })
|
||||
|
||||
expect(result.outcome).toBe('tie')
|
||||
if (result.outcome === 'tie') {
|
||||
expect(result.exAequoIds).toEqual(['alice', 'bob', 'carol'])
|
||||
expect(result.blanks).toBe(1)
|
||||
expect(result.participants).toBe(7)
|
||||
}
|
||||
})
|
||||
|
||||
it('never designates a winner among equals (no random, no first-come)', () => {
|
||||
// Same ballot tallied twice must yield the exact same tie.
|
||||
const ballot = [...votes(1, 'bob'), ...votes(1, 'alice')]
|
||||
const first = electionResult(ballot, {})
|
||||
const second = electionResult(ballot, {})
|
||||
expect(first).toEqual(second)
|
||||
expect(first.outcome).toBe('tie')
|
||||
})
|
||||
})
|
||||
|
||||
describe('electionResult — rejections', () => {
|
||||
it('quorum not reached => rejected with reason quorum and required', () => {
|
||||
const ballot = [...votes(2, 'alice'), ...votes(1)]
|
||||
const result = electionResult(ballot, { electionMinParticipants: 5 })
|
||||
|
||||
expect(result).toEqual({
|
||||
outcome: 'rejected',
|
||||
reason: 'quorum',
|
||||
participants: 3,
|
||||
required: 5,
|
||||
})
|
||||
})
|
||||
|
||||
it('quorum reached but all blanks => rejected with reason no-designation', () => {
|
||||
const ballot = votes(4)
|
||||
const result = electionResult(ballot, { electionMinParticipants: 3 })
|
||||
|
||||
expect(result).toEqual({
|
||||
outcome: 'rejected',
|
||||
reason: 'no-designation',
|
||||
participants: 4,
|
||||
required: 3,
|
||||
})
|
||||
})
|
||||
|
||||
it('zero votes without quorum => rejected no-designation (required 0)', () => {
|
||||
const result = electionResult([], {})
|
||||
expect(result).toEqual({
|
||||
outcome: 'rejected',
|
||||
reason: 'no-designation',
|
||||
participants: 0,
|
||||
required: 0,
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('electionResult — blanks and participation', () => {
|
||||
it('quorum reached THANKS to blanks: blanks count for participation', () => {
|
||||
// 3 designations alone would miss the quorum of 5; 2 blanks complete it.
|
||||
const ballot = [...votes(3, 'alice'), ...votes(2)]
|
||||
const result = electionResult(ballot, { electionMinParticipants: 5 })
|
||||
|
||||
expect(result).toEqual({
|
||||
outcome: 'elected',
|
||||
winnerId: 'alice',
|
||||
counts: { alice: 3 },
|
||||
blanks: 2,
|
||||
participants: 5,
|
||||
})
|
||||
})
|
||||
|
||||
it('exact quorum boundary: participants === required passes', () => {
|
||||
const ballot = [...votes(1, 'alice'), ...votes(1)]
|
||||
const result = electionResult(ballot, { electionMinParticipants: 2 })
|
||||
expect(result.outcome).toBe('elected')
|
||||
})
|
||||
|
||||
it('blanks never appear in counts', () => {
|
||||
const ballot = [...votes(2, 'alice'), ...votes(3)]
|
||||
const result = electionResult(ballot, {})
|
||||
if (result.outcome === 'elected') {
|
||||
expect(Object.keys(result.counts)).toEqual(['alice'])
|
||||
expect(result.blanks).toBe(3)
|
||||
} else {
|
||||
throw new Error(`expected elected, got ${result.outcome}`)
|
||||
}
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,158 @@
|
||||
/**
|
||||
* Tests du moteur de périmètre — computeConcerned / expandCircleMembers.
|
||||
* Fonctions pures : fixtures assemblées à la main, aucun store.
|
||||
*/
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { computeConcerned, expandCircleMembers } from '../../app/engine/impact'
|
||||
import type { Circle, Decision, Mandate } from '../../app/types/domain'
|
||||
|
||||
const T0 = '2026-01-01T00:00:00Z'
|
||||
const T9 = '2027-01-01T00:00:00Z'
|
||||
const AUTHOR = 'p-author'
|
||||
|
||||
function mkCircle(over: Partial<Circle> = {}): Circle {
|
||||
return {
|
||||
id: 'c1',
|
||||
collectiveId: 'col',
|
||||
createdAt: T0,
|
||||
updatedAt: T0,
|
||||
name: 'Forgerons',
|
||||
purpose: '',
|
||||
memberIds: [],
|
||||
domains: [],
|
||||
...over,
|
||||
}
|
||||
}
|
||||
|
||||
function mkMandate(over: Partial<Mandate> = {}): Mandate {
|
||||
return {
|
||||
id: 'm1',
|
||||
collectiveId: 'col',
|
||||
createdAt: T0,
|
||||
updatedAt: T0,
|
||||
title: 'Modération',
|
||||
holderId: 'p-holder',
|
||||
originDecisionId: 'd0',
|
||||
domain: { circleIds: ['c1'], tags: [] },
|
||||
startsAt: T0,
|
||||
endsAt: T9,
|
||||
electorCircleId: 'c1',
|
||||
nominationMethod: 'consent',
|
||||
reports: [],
|
||||
status: 'active',
|
||||
...over,
|
||||
}
|
||||
}
|
||||
|
||||
function mkScope(over: Partial<Decision['scope']> = {}): Decision['scope'] {
|
||||
return { selfOnly: false, circleIds: [], personIds: [], ...over }
|
||||
}
|
||||
|
||||
describe('computeConcerned — l\'union calculée, chaque entrée avec sa raison', () => {
|
||||
it('unit les trois sources : cercles, personnes nommées, titulaires de mandats', () => {
|
||||
const circles = [mkCircle({ id: 'c1', name: 'Forgerons', memberIds: ['p1', 'p2'] })]
|
||||
const mandates = [mkMandate({ holderId: 'p4', title: 'Modération' })]
|
||||
const scope = mkScope({ circleIds: ['c1'], personIds: ['p3'] })
|
||||
|
||||
const result = computeConcerned(scope, circles, mandates, AUTHOR)
|
||||
|
||||
expect(result).toHaveLength(4)
|
||||
expect(result).toContainEqual({ personId: 'p1', reason: 'membre du cercle Forgerons' })
|
||||
expect(result).toContainEqual({ personId: 'p2', reason: 'membre du cercle Forgerons' })
|
||||
expect(result).toContainEqual({ personId: 'p3', reason: 'nommé·e par l\'auteur' })
|
||||
expect(result).toContainEqual({ personId: 'p4', reason: 'titulaire du mandat Modération' })
|
||||
})
|
||||
|
||||
it('dédoublonne — la première raison gagne, priorité cercle > nommé > mandat', () => {
|
||||
const circles = [mkCircle({ id: 'c1', name: 'Forgerons', memberIds: ['p1'] })]
|
||||
// p1 est membre du cercle ET nommé ET titulaire d'un mandat intersectant.
|
||||
const mandates = [mkMandate({ holderId: 'p1' })]
|
||||
const scope = mkScope({ circleIds: ['c1'], personIds: ['p1'] })
|
||||
|
||||
const result = computeConcerned(scope, circles, mandates, AUTHOR)
|
||||
|
||||
expect(result).toEqual([{ personId: 'p1', reason: 'membre du cercle Forgerons' }])
|
||||
})
|
||||
|
||||
it('dédoublonne — nommé·e gagne sur titulaire de mandat', () => {
|
||||
const mandates = [mkMandate({ holderId: 'p1', domain: { circleIds: ['c1'], tags: [] } })]
|
||||
const scope = mkScope({ circleIds: ['c1'], personIds: ['p1'] })
|
||||
|
||||
const result = computeConcerned(scope, [], mandates, AUTHOR)
|
||||
|
||||
expect(result).toEqual([{ personId: 'p1', reason: 'nommé·e par l\'auteur' }])
|
||||
})
|
||||
|
||||
it('exclut l\'auteur de toutes les sources', () => {
|
||||
const circles = [mkCircle({ id: 'c1', memberIds: [AUTHOR, 'p1'] })]
|
||||
const mandates = [mkMandate({ holderId: AUTHOR })]
|
||||
const scope = mkScope({ circleIds: ['c1'], personIds: [AUTHOR] })
|
||||
|
||||
const result = computeConcerned(scope, circles, mandates, AUTHOR)
|
||||
|
||||
expect(result.map(e => e.personId)).toEqual(['p1'])
|
||||
})
|
||||
|
||||
it('n\'inclut un titulaire que si le domaine du mandat intersecte les cercles du périmètre', () => {
|
||||
const mandates = [
|
||||
mkMandate({ id: 'm1', holderId: 'p4', domain: { circleIds: ['c9'], tags: [] } }),
|
||||
mkMandate({ id: 'm2', holderId: 'p5', title: 'Trésorerie', domain: { circleIds: ['c2', 'c1'], tags: [] } }),
|
||||
]
|
||||
const scope = mkScope({ circleIds: ['c1'] })
|
||||
|
||||
const result = computeConcerned(scope, [], mandates, AUTHOR)
|
||||
|
||||
expect(result).toEqual([{ personId: 'p5', reason: 'titulaire du mandat Trésorerie' }])
|
||||
})
|
||||
|
||||
it('ignore les mandats non actifs', () => {
|
||||
const mandates = [mkMandate({ holderId: 'p4', status: 'expired' })]
|
||||
const scope = mkScope({ circleIds: ['c1'] })
|
||||
|
||||
expect(computeConcerned(scope, [], mandates, AUTHOR)).toEqual([])
|
||||
})
|
||||
|
||||
it('ignore sans erreur un cercle inconnu dans le périmètre', () => {
|
||||
const scope = mkScope({ circleIds: ['c-fantome'], personIds: ['p1'] })
|
||||
|
||||
const result = computeConcerned(scope, [], [], AUTHOR)
|
||||
|
||||
expect(result).toEqual([{ personId: 'p1', reason: 'nommé·e par l\'auteur' }])
|
||||
})
|
||||
})
|
||||
|
||||
describe('expandCircleMembers — appartenance nominative, sans propagation', () => {
|
||||
it('réunit les membres directs de plusieurs cercles, dédoublonnés', () => {
|
||||
const circles = [
|
||||
mkCircle({ id: 'c1', memberIds: ['p1', 'p2'] }),
|
||||
mkCircle({ id: 'c2', name: 'Cuisine', memberIds: ['p2', 'p3'] }),
|
||||
]
|
||||
|
||||
const members = expandCircleMembers(['c1', 'c2'], circles)
|
||||
|
||||
expect(members).toEqual(new Set(['p1', 'p2', 'p3']))
|
||||
})
|
||||
|
||||
it('ne propage PAS l\'appartenance des cercles enfants au parent (emboîtement ≠ appartenance)', () => {
|
||||
// v2 : l'appartenance est nominative par cercle ; l'emboîtement
|
||||
// (parentCircleId) sert l'élargissement d'un cran, jamais le calcul.
|
||||
const parent = mkCircle({ id: 'c-parent', name: 'Village', memberIds: ['p1'] })
|
||||
const child = mkCircle({
|
||||
id: 'c-child',
|
||||
name: 'Hameau',
|
||||
memberIds: ['p2'],
|
||||
parentCircleId: 'c-parent',
|
||||
})
|
||||
|
||||
expect(expandCircleMembers(['c-parent'], [parent, child])).toEqual(new Set(['p1']))
|
||||
// Ni dans l'autre sens : l'enfant n'hérite pas des membres du parent.
|
||||
expect(expandCircleMembers(['c-child'], [parent, child])).toEqual(new Set(['p2']))
|
||||
// L'élargissement est un geste explicite : ajouter le cercle au périmètre.
|
||||
expect(expandCircleMembers(['c-parent', 'c-child'], [parent, child]))
|
||||
.toEqual(new Set(['p1', 'p2']))
|
||||
})
|
||||
|
||||
it('ignore un identifiant de cercle inconnu', () => {
|
||||
expect(expandCircleMembers(['c-fantome'], [mkCircle()])).toEqual(new Set())
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,480 @@
|
||||
/**
|
||||
* Suite du moteur paramétrique — « Réglage collectif » (BLUEPRINT-V2.md
|
||||
* Δ2, Δ3, Δ15, Δ16). Specs verrouillées testées ici :
|
||||
* médiane BASSE élément par élément (pair ⇒ élément central inférieur,
|
||||
* step respecté par construction), sum100 avec EXACTEMENT une part dérivée,
|
||||
* clamp + renormalisation proportionnelle à la cristallisation,
|
||||
* « Pour moi » linear-share (jamais de chiffre inventé), bimodalité
|
||||
* heuristique jamais bloquante, dégénérescences 0 vote.
|
||||
*/
|
||||
import type { ParamSpec } from '../../app/types/domain'
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import {
|
||||
computeMyImpact,
|
||||
crystallize,
|
||||
detectBimodality,
|
||||
medianByElement,
|
||||
resolveDerived,
|
||||
validateParamSpec,
|
||||
validateVote,
|
||||
} from '../../app/engine/parametric'
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Specs de référence
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Spec sum100 : 2 parts votées + 1 part dérivée large (bornes 0–100). */
|
||||
function sum100Spec(overrides: Partial<ParamSpec> = {}): ParamSpec {
|
||||
return {
|
||||
constraint: 'sum100',
|
||||
params: [
|
||||
{ key: 'bois', label: 'Atelier bois', kind: 'share', min: 0, max: 100, step: 5 },
|
||||
{ key: 'metal', label: 'Atelier métal', kind: 'share', min: 0, max: 100, step: 5 },
|
||||
{ key: 'reserve', label: 'Réserve (calculé)', kind: 'share', min: 0, max: 100, step: 1, derived: true },
|
||||
],
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
/** Spec sans contrainte : 2 curseurs bornés. */
|
||||
function sliderSpec(): ParamSpec {
|
||||
return {
|
||||
constraint: 'none',
|
||||
params: [
|
||||
{ key: 'duree', label: 'Durée (mois)', kind: 'slider', min: 1, max: 24, step: 1, baseline: 12 },
|
||||
{ key: 'taux', label: 'Taux (%)', kind: 'slider', min: 0, max: 10, step: 0.5 },
|
||||
],
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// medianByElement — médiane basse élément par élément
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('medianByElement — médiane basse élément par élément', () => {
|
||||
it('nombre impair de votes : élément central classique', () => {
|
||||
expect(medianByElement([[10], [30], [20]])).toEqual([20])
|
||||
})
|
||||
|
||||
it('nombre pair de votes : élément central INFÉRIEUR (médiane basse)', () => {
|
||||
// Colonne triée [10, 20, 30, 40] : index floor((4-1)/2) = 1 ⇒ 20, pas 25.
|
||||
expect(medianByElement([[40], [10], [30], [20]])).toEqual([20])
|
||||
})
|
||||
|
||||
it('la médiane paire est la valeur votée inférieure des deux centrales', () => {
|
||||
const votes = [[15], [25], [40], [60]]
|
||||
const [median] = medianByElement(votes)
|
||||
expect(median).toBe(25) // jamais 32.5 (moyenne des centrales)
|
||||
expect(votes.flat()).toContain(median) // une position que quelqu'un a votée
|
||||
})
|
||||
|
||||
it('step respecté par construction : la médiane appartient à la grille votée', () => {
|
||||
// Votes conformes au pas 5 : la médiane basse est l'un d'eux, donc conforme.
|
||||
const votes = [[15], [25], [40], [60]]
|
||||
const [median] = medianByElement(votes)
|
||||
expect((median - 0) % 5).toBe(0)
|
||||
})
|
||||
|
||||
it('élément par élément : chaque colonne a sa propre médiane', () => {
|
||||
const votes = [
|
||||
[10, 90],
|
||||
[20, 80],
|
||||
[30, 70],
|
||||
]
|
||||
expect(medianByElement(votes)).toEqual([20, 80])
|
||||
})
|
||||
|
||||
it('deux votes : médiane basse = le plus petit des deux', () => {
|
||||
expect(medianByElement([[50, 10], [40, 20]])).toEqual([40, 10])
|
||||
})
|
||||
|
||||
it('0 vote ⇒ [] (l’appelant gère la baseline)', () => {
|
||||
expect(medianByElement([])).toEqual([])
|
||||
})
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// validateParamSpec
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('validateParamSpec — validation de la spec à la création', () => {
|
||||
it('accepte une spec sum100 valide (exactement une part dérivée)', () => {
|
||||
expect(() => validateParamSpec(sum100Spec())).not.toThrow()
|
||||
})
|
||||
|
||||
it('accepte une spec de curseurs sans contrainte', () => {
|
||||
expect(() => validateParamSpec(sliderSpec())).not.toThrow()
|
||||
})
|
||||
|
||||
it('rejette plus de 7 paramètres', () => {
|
||||
const spec: ParamSpec = {
|
||||
constraint: 'none',
|
||||
params: Array.from({ length: 8 }, (_, i) => ({
|
||||
key: `p${i}`,
|
||||
label: `Paramètre ${i}`,
|
||||
kind: 'slider' as const,
|
||||
min: 0,
|
||||
max: 10,
|
||||
step: 1,
|
||||
})),
|
||||
}
|
||||
expect(() => validateParamSpec(spec)).toThrow(/maximum 7/)
|
||||
})
|
||||
|
||||
it('rejette une spec sans aucun paramètre', () => {
|
||||
expect(() => validateParamSpec({ constraint: 'none', params: [] })).toThrow(/Au moins un paramètre/)
|
||||
})
|
||||
|
||||
it('rejette un libellé métier manquant', () => {
|
||||
const spec = sliderSpec()
|
||||
spec.params[0].label = ' '
|
||||
expect(() => validateParamSpec(spec)).toThrow(/Libellé métier manquant/)
|
||||
})
|
||||
|
||||
it('rejette sum100 sans part dérivée (0 derived)', () => {
|
||||
const spec = sum100Spec()
|
||||
delete spec.params[2].derived
|
||||
expect(() => validateParamSpec(spec)).toThrow(/exactement une part dérivée/)
|
||||
})
|
||||
|
||||
it('rejette sum100 avec deux parts dérivées (2 derived)', () => {
|
||||
const spec = sum100Spec()
|
||||
spec.params[1].derived = true
|
||||
expect(() => validateParamSpec(spec)).toThrow(/2 trouvées/)
|
||||
})
|
||||
|
||||
it('rejette un derived posé sur un curseur (kind slider)', () => {
|
||||
const spec = sum100Spec()
|
||||
spec.params[2].kind = 'slider'
|
||||
expect(() => validateParamSpec(spec)).toThrow(/part/)
|
||||
})
|
||||
|
||||
it('rejette un derived sans contrainte pour le résoudre', () => {
|
||||
const spec = sliderSpec()
|
||||
spec.params[1].derived = true
|
||||
expect(() => validateParamSpec(spec)).toThrow(/sans contrainte/)
|
||||
})
|
||||
|
||||
it('rejette des bornes incohérentes (min >= max)', () => {
|
||||
const spec = sliderSpec()
|
||||
spec.params[0].min = 24
|
||||
spec.params[0].max = 24
|
||||
expect(() => validateParamSpec(spec)).toThrow(/Bornes incohérentes/)
|
||||
})
|
||||
|
||||
it('rejette un pas nul ou négatif (step <= 0)', () => {
|
||||
const spec = sliderSpec()
|
||||
spec.params[1].step = 0
|
||||
expect(() => validateParamSpec(spec)).toThrow(/Pas invalide/)
|
||||
spec.params[1].step = -1
|
||||
expect(() => validateParamSpec(spec)).toThrow(/Pas invalide/)
|
||||
})
|
||||
|
||||
it('rejette une baseline hors bornes', () => {
|
||||
const spec = sliderSpec()
|
||||
spec.params[0].baseline = 25 // max 24
|
||||
expect(() => validateParamSpec(spec)).toThrow(/hors bornes/)
|
||||
})
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// validateVote
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('validateVote — validation d’un vote', () => {
|
||||
it('accepte un vote valide (ordre des params hors derived)', () => {
|
||||
expect(() => validateVote(sum100Spec(), [60, 30])).not.toThrow()
|
||||
expect(() => validateVote(sliderSpec(), [12, 2.5])).not.toThrow()
|
||||
})
|
||||
|
||||
it('rejette une longueur fausse (le derived ne se vote pas)', () => {
|
||||
expect(() => validateVote(sum100Spec(), [60, 30, 10])).toThrow(/Nombre de valeurs invalide/)
|
||||
expect(() => validateVote(sum100Spec(), [60])).toThrow(/Nombre de valeurs invalide/)
|
||||
})
|
||||
|
||||
it('rejette NaN et Infinity (sanitize)', () => {
|
||||
expect(() => validateVote(sum100Spec(), [Number.NaN, 30])).toThrow(/nombre fini/)
|
||||
expect(() => validateVote(sum100Spec(), [60, Number.POSITIVE_INFINITY])).toThrow(/nombre fini/)
|
||||
expect(() => validateVote(sliderSpec(), [Number.NEGATIVE_INFINITY, 2])).toThrow(/nombre fini/)
|
||||
})
|
||||
|
||||
it('rejette une valeur hors bornes', () => {
|
||||
expect(() => validateVote(sliderSpec(), [0, 2])).toThrow(/hors bornes/) // min 1
|
||||
expect(() => validateVote(sliderSpec(), [12, 10.5])).toThrow(/hors bornes/) // max 10
|
||||
})
|
||||
|
||||
it('rejette une valeur non alignée sur le pas', () => {
|
||||
expect(() => validateVote(sum100Spec(), [62, 30])).toThrow(/pas/) // pas de 5
|
||||
expect(() => validateVote(sliderSpec(), [12, 2.3])).toThrow(/pas/) // pas de 0.5
|
||||
})
|
||||
|
||||
it('tolérance flottante : 0.1 + 0.2 est accepté sur une grille de 0.1', () => {
|
||||
const spec: ParamSpec = {
|
||||
constraint: 'none',
|
||||
params: [{ key: 't', label: 'Taux', kind: 'slider', min: 0, max: 1, step: 0.1 }],
|
||||
}
|
||||
expect(() => validateVote(spec, [0.1 + 0.2])).not.toThrow() // 0.30000000000000004
|
||||
})
|
||||
|
||||
it('sum100 : rejette le vote si le derived résolu sort de ses bornes', () => {
|
||||
const spec = sum100Spec()
|
||||
spec.params[2].max = 15 // réserve bornée [0, 15]
|
||||
// 60 + 30 = 90 ⇒ derived 10 : OK ; 50 + 30 = 80 ⇒ derived 20 : rejet.
|
||||
expect(() => validateVote(spec, [60, 30])).not.toThrow()
|
||||
expect(() => validateVote(spec, [50, 30])).toThrow(/sortirait de ses bornes/)
|
||||
// 105 votés ⇒ derived −5 < min 0 : rejet aussi.
|
||||
expect(() => validateVote(spec, [70, 35])).toThrow(/sortirait de ses bornes/)
|
||||
})
|
||||
|
||||
it('sum100 : le derived exactement sur sa borne est accepté', () => {
|
||||
const spec = sum100Spec()
|
||||
spec.params[2].max = 5
|
||||
expect(() => validateVote(spec, [65, 30])).not.toThrow() // derived = 5 pile
|
||||
})
|
||||
|
||||
it('sum100 : un curseur hors contrainte ne compte pas dans la somme', () => {
|
||||
const spec: ParamSpec = {
|
||||
constraint: 'sum100',
|
||||
params: [
|
||||
{ key: 'duree', label: 'Durée (mois)', kind: 'slider', min: 1, max: 24, step: 1 },
|
||||
{ key: 'bois', label: 'Atelier bois', kind: 'share', min: 0, max: 100, step: 5 },
|
||||
{ key: 'reserve', label: 'Réserve (calculé)', kind: 'share', min: 0, max: 100, step: 1, derived: true },
|
||||
],
|
||||
}
|
||||
// Le curseur vaut 24 : s'il comptait, derived = 100 − 24 − 60 = 16 ;
|
||||
// il ne compte pas ⇒ derived = 40, dans [0, 100].
|
||||
expect(() => validateVote(spec, [24, 60])).not.toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// resolveDerived
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('resolveDerived — résolution linéaire du derived', () => {
|
||||
it('insère le derived à sa position dans l’ordre de spec.params', () => {
|
||||
expect(resolveDerived(sum100Spec(), [60, 30])).toEqual([60, 30, 10])
|
||||
})
|
||||
|
||||
it('derived en position centrale : l’ordre est préservé', () => {
|
||||
const spec: ParamSpec = {
|
||||
constraint: 'sum100',
|
||||
params: [
|
||||
{ key: 'a', label: 'Part A', kind: 'share', min: 0, max: 100, step: 1 },
|
||||
{ key: 'r', label: 'Réserve (calculé)', kind: 'share', min: 0, max: 100, step: 1, derived: true },
|
||||
{ key: 'b', label: 'Part B', kind: 'share', min: 0, max: 100, step: 1 },
|
||||
],
|
||||
}
|
||||
expect(resolveDerived(spec, [40, 35])).toEqual([40, 25, 35])
|
||||
})
|
||||
|
||||
it('les curseurs hors contrainte passent tels quels', () => {
|
||||
expect(resolveDerived(sliderSpec(), [12, 2.5])).toEqual([12, 2.5])
|
||||
})
|
||||
|
||||
it('sum100 avec curseur : seul les parts entrent dans le calcul du derived', () => {
|
||||
const spec: ParamSpec = {
|
||||
constraint: 'sum100',
|
||||
params: [
|
||||
{ key: 'duree', label: 'Durée (mois)', kind: 'slider', min: 1, max: 24, step: 1 },
|
||||
{ key: 'bois', label: 'Atelier bois', kind: 'share', min: 0, max: 100, step: 5 },
|
||||
{ key: 'reserve', label: 'Réserve (calculé)', kind: 'share', min: 0, max: 100, step: 1, derived: true },
|
||||
],
|
||||
}
|
||||
expect(resolveDerived(spec, [24, 60])).toEqual([24, 60, 40])
|
||||
})
|
||||
|
||||
it('rejette une longueur fausse', () => {
|
||||
expect(() => resolveDerived(sum100Spec(), [60])).toThrow(/Nombre de valeurs invalide/)
|
||||
})
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// crystallize
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('crystallize — médiane basse des parts votées puis résolution', () => {
|
||||
it('cas nominal : médiane basse puis derived résolu, somme 100', () => {
|
||||
const votes = [
|
||||
[50, 20],
|
||||
[60, 30],
|
||||
[70, 40],
|
||||
]
|
||||
const out = crystallize(sum100Spec(), votes)
|
||||
expect(out).toEqual([60, 30, 10])
|
||||
expect(out[0] + out[1] + out[2]).toBe(100)
|
||||
})
|
||||
|
||||
it('derived dans ses bornes : aucun clamp, valeurs médianes intactes', () => {
|
||||
const spec = sum100Spec()
|
||||
spec.params[2].max = 15
|
||||
const out = crystallize(spec, [[60, 30], [65, 30], [55, 35]])
|
||||
expect(out).toEqual([60, 30, 10]) // derived 10 ≤ 15 : rien à clamper
|
||||
})
|
||||
|
||||
it('cas chiffré exact : derived clampé à 5, parts renormalisées ×95/90', () => {
|
||||
// Médiane des parts votées = {60, 30} ⇒ derived résolu 10 > max 5.
|
||||
// Spec verrouillée : clamp à 5, puis parts × (100 − 5)/(60 + 30).
|
||||
const spec = sum100Spec()
|
||||
spec.params[2].max = 5
|
||||
const votes = [
|
||||
[50, 20],
|
||||
[60, 30],
|
||||
[70, 40],
|
||||
]
|
||||
const out = crystallize(spec, votes)
|
||||
expect(out[2]).toBe(5)
|
||||
expect(out[0]).toBeCloseTo((60 * 95) / 90, 10)
|
||||
expect(out[1]).toBeCloseTo((30 * 95) / 90, 10)
|
||||
expect(out[0] + out[1] + out[2]).toBeCloseTo(100, 10)
|
||||
})
|
||||
|
||||
it('clamp à la borne min : même renormalisation proportionnelle', () => {
|
||||
// Médiane {60, 30} ⇒ derived 10 < min 20 : clamp à 20, parts × 80/90.
|
||||
const spec = sum100Spec()
|
||||
spec.params[2].min = 20
|
||||
const out = crystallize(spec, [[60, 30]])
|
||||
expect(out[2]).toBe(20)
|
||||
expect(out[0]).toBeCloseTo((60 * 80) / 90, 10)
|
||||
expect(out[1]).toBeCloseTo((30 * 80) / 90, 10)
|
||||
expect(out[0] + out[1] + out[2]).toBeCloseTo(100, 10)
|
||||
})
|
||||
|
||||
it('les curseurs hors contrainte ne sont jamais renormalisés', () => {
|
||||
const spec: ParamSpec = {
|
||||
constraint: 'sum100',
|
||||
params: [
|
||||
{ key: 'duree', label: 'Durée (mois)', kind: 'slider', min: 1, max: 24, step: 1 },
|
||||
{ key: 'bois', label: 'Atelier bois', kind: 'share', min: 0, max: 100, step: 5 },
|
||||
{ key: 'metal', label: 'Atelier métal', kind: 'share', min: 0, max: 100, step: 5 },
|
||||
{ key: 'reserve', label: 'Réserve (calculé)', kind: 'share', min: 0, max: 5, step: 1, derived: true },
|
||||
],
|
||||
}
|
||||
const out = crystallize(spec, [[12, 60, 30]])
|
||||
expect(out[0]).toBe(12) // le curseur passe tel quel
|
||||
expect(out[3]).toBe(5)
|
||||
expect(out[1] + out[2] + out[3]).toBeCloseTo(100, 10)
|
||||
})
|
||||
|
||||
it('0 vote ⇒ vecteur des baselines (baseline ?? min)', () => {
|
||||
const spec = sum100Spec()
|
||||
spec.params[0].baseline = 50
|
||||
spec.params[2].baseline = 20
|
||||
// params[1] sans baseline ⇒ min (0).
|
||||
expect(crystallize(spec, [])).toEqual([50, 0, 20])
|
||||
})
|
||||
|
||||
it('0 vote sans aucune baseline ⇒ vecteur des min', () => {
|
||||
expect(crystallize(sliderSpec(), [])).toEqual([12, 0]) // duree a baseline 12, taux min 0
|
||||
})
|
||||
|
||||
it('sans contrainte : médiane basse simple, aucun derived', () => {
|
||||
const out = crystallize(sliderSpec(), [[6, 2], [12, 4], [18, 3], [24, 5]])
|
||||
expect(out).toEqual([12, 3]) // médiane basse de chaque colonne
|
||||
})
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// computeMyImpact
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('computeMyImpact — carte « Pour moi » (linear-share)', () => {
|
||||
function impactSpec(): ParamSpec {
|
||||
const spec = sum100Spec()
|
||||
spec.impactAttrKey = 'heures/mois'
|
||||
return spec
|
||||
}
|
||||
|
||||
it('cas nominal chiffré : quote-parts au prorata de l’attribut déclaré', () => {
|
||||
// 1 200 € ; valeurs [50, 30, 20] ; moi 10 h, corpus [10, 20, 10] ⇒ Σ 40.
|
||||
// montants : 600, 360, 240 ; ma quote-part = montant × 10/40.
|
||||
const result = computeMyImpact(impactSpec(), { amount: 1200 }, [50, 30, 20], 10, [10, 20, 10])
|
||||
expect(result).not.toBeNull()
|
||||
expect(result!.perParam).toEqual([
|
||||
{ key: 'bois', label: 'Atelier bois', amount: 150 },
|
||||
{ key: 'metal', label: 'Atelier métal', amount: 90 },
|
||||
{ key: 'reserve', label: 'Réserve (calculé)', amount: 60 },
|
||||
])
|
||||
expect(result!.total).toBeCloseTo(300, 10)
|
||||
})
|
||||
|
||||
it('le derived est inclus dans les quote-parts (chaque part compte)', () => {
|
||||
const result = computeMyImpact(impactSpec(), { amount: 1200 }, [50, 30, 20], 10, [10, 20, 10])
|
||||
expect(result!.perParam.map(l => l.key)).toContain('reserve')
|
||||
})
|
||||
|
||||
it('null si mon attribut est absent — jamais de chiffre inventé', () => {
|
||||
expect(computeMyImpact(impactSpec(), { amount: 1200 }, [50, 30, 20], undefined, [10, 20])).toBeNull()
|
||||
})
|
||||
|
||||
it('null si Σ des attributs du corpus vaut 0', () => {
|
||||
expect(computeMyImpact(impactSpec(), { amount: 1200 }, [50, 30, 20], 10, [0, 0, 0])).toBeNull()
|
||||
expect(computeMyImpact(impactSpec(), { amount: 1200 }, [50, 30, 20], 10, [])).toBeNull()
|
||||
})
|
||||
|
||||
it('null hors sum100, sans montant ou sans impactAttrKey', () => {
|
||||
const noConstraint = sliderSpec()
|
||||
noConstraint.impactAttrKey = 'heures/mois'
|
||||
expect(computeMyImpact(noConstraint, { amount: 1200 }, [12, 2.5], 10, [10, 20])).toBeNull()
|
||||
|
||||
expect(computeMyImpact(impactSpec(), {}, [50, 30, 20], 10, [10, 20])).toBeNull()
|
||||
|
||||
const noKey = sum100Spec() // pas d'impactAttrKey
|
||||
expect(computeMyImpact(noKey, { amount: 1200 }, [50, 30, 20], 10, [10, 20])).toBeNull()
|
||||
})
|
||||
|
||||
it('les curseurs hors contrainte n’ont pas de quote-part', () => {
|
||||
const spec: ParamSpec = {
|
||||
constraint: 'sum100',
|
||||
impactAttrKey: 'heures/mois',
|
||||
params: [
|
||||
{ key: 'duree', label: 'Durée (mois)', kind: 'slider', min: 1, max: 24, step: 1 },
|
||||
{ key: 'bois', label: 'Atelier bois', kind: 'share', min: 0, max: 100, step: 5 },
|
||||
{ key: 'reserve', label: 'Réserve (calculé)', kind: 'share', min: 0, max: 100, step: 1, derived: true },
|
||||
],
|
||||
}
|
||||
const result = computeMyImpact(spec, { amount: 1000 }, [12, 60, 40], 5, [5, 5])
|
||||
expect(result!.perParam.map(l => l.key)).toEqual(['bois', 'reserve'])
|
||||
expect(result!.total).toBeCloseTo(500, 10) // (600 + 400) × 5/10
|
||||
})
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// detectBimodality
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('detectBimodality — heuristique jamais bloquante', () => {
|
||||
it('bimodal net : deux paquets séparés par un grand écart ⇒ vrai', () => {
|
||||
// Triées : [10, 11, 12, 60, 61, 62] — étendue 52, gap max 48 > 40 %.
|
||||
expect(detectBimodality([10, 60, 11, 61, 12, 62])).toBe(true)
|
||||
})
|
||||
|
||||
it('distribution uniforme ⇒ faux', () => {
|
||||
// Gaps réguliers de 10 sur une étendue de 40 : 10 < 16.
|
||||
expect(detectBimodality([10, 20, 30, 40, 50])).toBe(false)
|
||||
})
|
||||
|
||||
it('moins de 4 valeurs ⇒ toujours faux', () => {
|
||||
expect(detectBimodality([0, 100])).toBe(false)
|
||||
expect(detectBimodality([0, 50, 100])).toBe(false)
|
||||
expect(detectBimodality([])).toBe(false)
|
||||
})
|
||||
|
||||
it('un simple outlier (1 seule valeur d’un côté du gap) ⇒ faux', () => {
|
||||
// Gap max 50 entre 0 et 50, mais une seule valeur à gauche.
|
||||
expect(detectBimodality([0, 50, 51, 52, 53])).toBe(false)
|
||||
})
|
||||
|
||||
it('valeurs toutes identiques (étendue nulle) ⇒ faux', () => {
|
||||
expect(detectBimodality([5, 5, 5, 5])).toBe(false)
|
||||
})
|
||||
|
||||
it('deux paires exactement de part et d’autre du gap ⇒ vrai (cas limite n=4)', () => {
|
||||
expect(detectBimodality([0, 1, 99, 100])).toBe(true)
|
||||
})
|
||||
|
||||
it('jamais bloquante : les valeurs non finies sont ignorées, pas d’exception', () => {
|
||||
expect(() => detectBimodality([Number.NaN, Number.POSITIVE_INFINITY, 1, 2])).not.toThrow()
|
||||
expect(detectBimodality([Number.NaN, 0, 1, 99, 100])).toBe(true)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,226 @@
|
||||
/**
|
||||
* resolveSettings — the Pact IS the settings store (Δ10).
|
||||
* Defaults, voted overrides, specified fallbacks, corrupted-bundle resilience.
|
||||
*/
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { SETTINGS_DEFAULTS, hasConsentProtocol, resolveSettings } from '../../app/engine/settings'
|
||||
import type { Clause, ClauseVersion, Json } from '../../app/types/domain'
|
||||
|
||||
const T0 = '2026-08-01T00:00:00.000Z'
|
||||
const T1 = '2026-08-05T00:00:00.000Z'
|
||||
|
||||
let seq = 0
|
||||
|
||||
function makeClause(settingKey: string, overrides: Partial<Clause> = {}): Clause {
|
||||
seq += 1
|
||||
return {
|
||||
id: `clause-${seq}`,
|
||||
collectiveId: 'col-1',
|
||||
createdAt: T0,
|
||||
updatedAt: T0,
|
||||
docId: 'doc-pact',
|
||||
section: 'Réglages',
|
||||
position: seq,
|
||||
code: `S${seq}`,
|
||||
title: settingKey,
|
||||
inertia: 'standard',
|
||||
settingKey,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
function makeVersion(
|
||||
clauseId: string,
|
||||
settingValue: Json,
|
||||
overrides: Partial<ClauseVersion> = {},
|
||||
): ClauseVersion {
|
||||
seq += 1
|
||||
return {
|
||||
id: `version-${seq}`,
|
||||
collectiveId: 'col-1',
|
||||
createdAt: T0,
|
||||
updatedAt: T0,
|
||||
clauseId,
|
||||
decisionId: 'dec-founding',
|
||||
versionLabel: 'v1',
|
||||
content: 'clause adoptée',
|
||||
settingValue,
|
||||
status: 'current',
|
||||
adoptedAt: T0,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
/** Build a Pact from [settingKey, settingValue] pairs and resolve it. */
|
||||
function resolveFrom(entries: [string, Json][]) {
|
||||
const clauses = entries.map(([key]) => makeClause(key))
|
||||
const versions = clauses.map((clause, index) => makeVersion(clause.id, entries[index]![1]))
|
||||
return resolveSettings(clauses, versions)
|
||||
}
|
||||
|
||||
describe('resolveSettings — les défauts complets', () => {
|
||||
it('sans aucune clause, tous les seuils de triage prennent leur défaut', () => {
|
||||
const settings = resolveSettings([], [])
|
||||
expect(settings.triage).toEqual({
|
||||
smallGroupMax: 5,
|
||||
collectiveMin: 50,
|
||||
consentMax: 7,
|
||||
objectionWindowHours: 48,
|
||||
adviceWindowHours: 72,
|
||||
framingDays: 14,
|
||||
concernEscalateRatio: 0.5,
|
||||
recurrenceThreshold: 3,
|
||||
reviewDelayDays: 90,
|
||||
requireEffects: 'binding',
|
||||
})
|
||||
expect(settings.triage).toEqual(SETTINGS_DEFAULTS)
|
||||
})
|
||||
|
||||
it('sans aucune clause, les protocoles optionnels restent indéfinis (repli → consent chez l’appelant)', () => {
|
||||
const settings = resolveSettings([], [])
|
||||
expect(settings.protocolByRange.nuanced).toBeUndefined()
|
||||
expect(settings.protocolByRange.large).toBeUndefined()
|
||||
expect(settings.protocolByRange.parametric).toBeUndefined()
|
||||
expect(settings.protocolByRange.election).toBeUndefined()
|
||||
expect(settings.protocolByRange.clauseByInertia).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveSettings — une clause adoptée change une valeur', () => {
|
||||
it('la version courante d’une clause remplace le défaut', () => {
|
||||
const settings = resolveFrom([['triage.smallGroupMax', 8]])
|
||||
expect(settings.triage.smallGroupMax).toBe(8)
|
||||
expect(settings.triage.collectiveMin).toBe(50) // les autres clés gardent leur défaut
|
||||
})
|
||||
|
||||
it('une version seulement proposée ne change rien', () => {
|
||||
const clause = makeClause('triage.framingDays')
|
||||
const version = makeVersion(clause.id, 21, { status: 'proposed', adoptedAt: undefined })
|
||||
expect(resolveSettings([clause], [version]).triage.framingDays).toBe(14)
|
||||
})
|
||||
|
||||
it('une version remplacée ne change rien — seule la courante compte', () => {
|
||||
const clause = makeClause('triage.consentMax')
|
||||
const superseded = makeVersion(clause.id, 3, { status: 'superseded' })
|
||||
const current = makeVersion(clause.id, 9, { adoptedAt: T1 })
|
||||
expect(resolveSettings([clause], [superseded, current]).triage.consentMax).toBe(9)
|
||||
})
|
||||
|
||||
it('deux versions courantes (anomalie) — la plus récemment adoptée gagne', () => {
|
||||
const clause = makeClause('triage.objectionWindowHours')
|
||||
const older = makeVersion(clause.id, 24, { adoptedAt: T0 })
|
||||
const newer = makeVersion(clause.id, 96, { adoptedAt: T1 })
|
||||
expect(resolveSettings([clause], [older, newer]).triage.objectionWindowHours).toBe(96)
|
||||
})
|
||||
|
||||
it('une clause archivée est ignorée', () => {
|
||||
const clause = makeClause('triage.smallGroupMax', { archivedAt: T1 })
|
||||
const version = makeVersion(clause.id, 12)
|
||||
expect(resolveSettings([clause], [version]).triage.smallGroupMax).toBe(5)
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveSettings — requireEffects résolu', () => {
|
||||
it('« none » voté est appliqué', () => {
|
||||
expect(resolveFrom([['triage.requireEffects', 'none']]).triage.requireEffects).toBe('none')
|
||||
})
|
||||
|
||||
it('« structural » voté est appliqué', () => {
|
||||
expect(resolveFrom([['triage.requireEffects', 'structural']]).triage.requireEffects).toBe(
|
||||
'structural',
|
||||
)
|
||||
})
|
||||
|
||||
it('une valeur inconnue retombe sur « binding »', () => {
|
||||
expect(resolveFrom([['triage.requireEffects', 'everything']]).triage.requireEffects).toBe(
|
||||
'binding',
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveSettings — le protocole de consentement', () => {
|
||||
it('la clause protocols.consent résout l’identifiant', () => {
|
||||
const settings = resolveFrom([['protocols.consent', 'proto-consent-1']])
|
||||
expect(settings.protocolByRange.consent).toBe('proto-consent-1')
|
||||
expect(hasConsentProtocol(settings)).toBe(true)
|
||||
})
|
||||
|
||||
it('consent introuvable (bundle corrompu) — objet complet, consent vide, jamais de crash', () => {
|
||||
expect(() => resolveSettings([], [])).not.toThrow()
|
||||
const settings = resolveSettings([], [])
|
||||
expect(settings.protocolByRange.consent).toBe('')
|
||||
expect(hasConsentProtocol(settings)).toBe(false)
|
||||
expect(settings.triage.smallGroupMax).toBe(5) // le reste de l’objet est utilisable
|
||||
})
|
||||
|
||||
it('consent d’un mauvais type compte comme introuvable', () => {
|
||||
const settings = resolveFrom([['protocols.consent', 42]])
|
||||
expect(settings.protocolByRange.consent).toBe('')
|
||||
expect(hasConsentProtocol(settings)).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveSettings — les protocoles optionnels et l’héritage Ğ1', () => {
|
||||
it('nuanced, large, parametric et election se résolvent chacun', () => {
|
||||
const settings = resolveFrom([
|
||||
['protocols.consent', 'p-consent'],
|
||||
['protocols.nuanced', 'p-nuanced'],
|
||||
['protocols.large', 'p-large'],
|
||||
['protocols.parametric', 'p-parametric'],
|
||||
['protocols.election', 'p-election'],
|
||||
])
|
||||
expect(settings.protocolByRange.nuanced).toBe('p-nuanced')
|
||||
expect(settings.protocolByRange.large).toBe('p-large')
|
||||
expect(settings.protocolByRange.parametric).toBe('p-parametric')
|
||||
expect(settings.protocolByRange.election).toBe('p-election')
|
||||
})
|
||||
|
||||
it('clauseByInertia complet (4 presets) est exposé', () => {
|
||||
const settings = resolveFrom([
|
||||
['protocols.clauseByInertia.low', 'p-low'],
|
||||
['protocols.clauseByInertia.standard', 'p-standard'],
|
||||
['protocols.clauseByInertia.high', 'p-high'],
|
||||
['protocols.clauseByInertia.max', 'p-max'],
|
||||
])
|
||||
expect(settings.protocolByRange.clauseByInertia).toEqual({
|
||||
low: 'p-low',
|
||||
standard: 'p-standard',
|
||||
high: 'p-high',
|
||||
max: 'p-max',
|
||||
})
|
||||
})
|
||||
|
||||
it('clauseByInertia partiel reste indéfini — l’appelant retombe sur consent', () => {
|
||||
const settings = resolveFrom([
|
||||
['protocols.clauseByInertia.low', 'p-low'],
|
||||
['protocols.clauseByInertia.standard', 'p-standard'],
|
||||
['protocols.clauseByInertia.high', 'p-high'],
|
||||
])
|
||||
expect(settings.protocolByRange.clauseByInertia).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveSettings — les valeurs invalides retombent sur les défauts, en silence', () => {
|
||||
it('un mauvais type sur une clé numérique est ignoré', () => {
|
||||
expect(resolveFrom([['triage.smallGroupMax', 'huit']]).triage.smallGroupMax).toBe(5)
|
||||
})
|
||||
|
||||
it('un nombre négatif est ignoré', () => {
|
||||
expect(resolveFrom([['triage.framingDays', -3]]).triage.framingDays).toBe(14)
|
||||
})
|
||||
|
||||
it('un ratio négatif est ignoré', () => {
|
||||
expect(resolveFrom([['triage.concernEscalateRatio', -0.5]]).triage.concernEscalateRatio).toBe(
|
||||
0.5,
|
||||
)
|
||||
})
|
||||
|
||||
it('null est ignoré', () => {
|
||||
expect(resolveFrom([['triage.reviewDelayDays', null]]).triage.reviewDelayDays).toBe(90)
|
||||
})
|
||||
|
||||
it('un identifiant de protocole vide compte comme non résolu', () => {
|
||||
const settings = resolveFrom([['protocols.nuanced', ' ']])
|
||||
expect(settings.protocolByRange.nuanced).toBeUndefined()
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,623 @@
|
||||
/**
|
||||
* canTransition — the ONE state machine of the decision (Δ29).
|
||||
* Every guard (a–i) tested with positive AND negative cases + windowOutcome.
|
||||
*/
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { TRANSITIONS, canTransition, windowOutcome } from '../../app/engine/state'
|
||||
import type { TransitionContext } from '../../app/engine/state'
|
||||
import type {
|
||||
Assent,
|
||||
CollectiveSettings,
|
||||
Concern,
|
||||
Decision,
|
||||
Objection,
|
||||
ParamSpec,
|
||||
VoteSession,
|
||||
} from '../../app/types/domain'
|
||||
|
||||
const T0 = '2026-08-01T00:00:00.000Z'
|
||||
const NOW = '2026-08-11T12:00:00.000Z'
|
||||
|
||||
let seq = 0
|
||||
|
||||
function makeEntity() {
|
||||
seq += 1
|
||||
return { id: `id-${seq}`, collectiveId: 'col-1', createdAt: T0, updatedAt: T0 }
|
||||
}
|
||||
|
||||
function makeSettings(overrides: Partial<CollectiveSettings['triage']> = {}): CollectiveSettings {
|
||||
return {
|
||||
triage: {
|
||||
smallGroupMax: 5,
|
||||
collectiveMin: 50,
|
||||
consentMax: 7,
|
||||
objectionWindowHours: 48,
|
||||
adviceWindowHours: 72,
|
||||
framingDays: 14,
|
||||
concernEscalateRatio: 0.5,
|
||||
recurrenceThreshold: 3,
|
||||
reviewDelayDays: 90,
|
||||
requireEffects: 'binding',
|
||||
...overrides,
|
||||
},
|
||||
protocolByRange: { consent: 'proto-consent' },
|
||||
}
|
||||
}
|
||||
|
||||
function makeDecision(overrides: Partial<Decision> = {}): Decision {
|
||||
return {
|
||||
...makeEntity(),
|
||||
id: 'dec-1',
|
||||
authorId: 'p-author',
|
||||
title: 'Décision de test',
|
||||
tags: [],
|
||||
reversibility: 'easy',
|
||||
weight: 'light',
|
||||
urgent: false,
|
||||
scope: { selfOnly: false, circleIds: ['circle-1'], personIds: [] },
|
||||
route: 'collective',
|
||||
triageRule: 'R5',
|
||||
routeOverridden: false,
|
||||
status: 'draft',
|
||||
stewardIds: [],
|
||||
measurerIds: [],
|
||||
visibility: 'scope',
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
function makeConcern(origin: Concern['origin'], overrides: Partial<Concern> = {}): Concern {
|
||||
const entity = makeEntity()
|
||||
return {
|
||||
...entity,
|
||||
decisionId: 'dec-1',
|
||||
personId: `p-${entity.id}`,
|
||||
origin,
|
||||
reason: 'membre du cercle',
|
||||
beforeSnapshot: true,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
function makeAssent(personId: string, overrides: Partial<Assent> = {}): Assent {
|
||||
return { ...makeEntity(), decisionId: 'dec-1', personId, ...overrides }
|
||||
}
|
||||
|
||||
function makeObjection(status: Objection['status'], overrides: Partial<Objection> = {}): Objection {
|
||||
return {
|
||||
...makeEntity(),
|
||||
decisionId: 'dec-1',
|
||||
personId: 'p-objector',
|
||||
kind: 'content',
|
||||
argument: 'Je maintiens mon désaccord.',
|
||||
status,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
function makeSession(overrides: Partial<VoteSession> = {}): VoteSession {
|
||||
return {
|
||||
...makeEntity(),
|
||||
decisionId: 'dec-1',
|
||||
protocolId: 'proto-1',
|
||||
corpusPersonIds: ['p-1', 'p-2', 'p-3'],
|
||||
corpusSize: 3,
|
||||
opensAt: T0,
|
||||
closesAt: NOW,
|
||||
status: 'open',
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
function makeCtx(overrides: Partial<TransitionContext> = {}): TransitionContext {
|
||||
return {
|
||||
concerns: [],
|
||||
settings: makeSettings(),
|
||||
assents: [],
|
||||
objections: [],
|
||||
now: NOW,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
const PARAM_SPEC: ParamSpec = {
|
||||
params: [
|
||||
{ key: 'partA', label: 'Part ateliers', kind: 'share', min: 0, max: 100, step: 1 },
|
||||
{ key: 'partB', label: 'Part réserve', kind: 'share', min: 0, max: 100, step: 1, derived: true },
|
||||
],
|
||||
constraint: 'sum100',
|
||||
}
|
||||
|
||||
/** 4 computed + 2 declared ⇒ ratio 0.5 atteint (2 ≥ 0.5 × 4). */
|
||||
function influxConcerns(): Concern[] {
|
||||
return [
|
||||
makeConcern('computed'),
|
||||
makeConcern('computed'),
|
||||
makeConcern('computed'),
|
||||
makeConcern('computed'),
|
||||
makeConcern('declared'),
|
||||
makeConcern('declared'),
|
||||
]
|
||||
}
|
||||
|
||||
describe('La table des transitions', () => {
|
||||
it('draft ouvre les sept chemins', () => {
|
||||
expect(TRANSITIONS.draft).toEqual([
|
||||
'advice',
|
||||
'objection',
|
||||
'framing',
|
||||
'voting',
|
||||
'adopted',
|
||||
'transmitted',
|
||||
'rejected',
|
||||
])
|
||||
})
|
||||
|
||||
it('chaque état de travail connaît ses sorties', () => {
|
||||
expect(TRANSITIONS.advice).toEqual(['adopted', 'voting'])
|
||||
expect(TRANSITIONS.objection).toEqual(['adopted', 'framing', 'voting'])
|
||||
expect(TRANSITIONS.framing).toEqual(['voting', 'closed'])
|
||||
expect(TRANSITIONS.voting).toEqual(['adopted', 'rejected'])
|
||||
expect(TRANSITIONS.adopted).toEqual(['revoked', 'closed'])
|
||||
})
|
||||
|
||||
it('les états terminaux n’ont aucune sortie', () => {
|
||||
expect(TRANSITIONS.rejected).toBeUndefined()
|
||||
expect(TRANSITIONS.revoked).toBeUndefined()
|
||||
expect(TRANSITIONS.closed).toBeUndefined()
|
||||
expect(TRANSITIONS.transmitted).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde a — la transition inconnue est refusée', () => {
|
||||
it('adopted → voting n’existe pas', () => {
|
||||
const result = canTransition(makeDecision({ status: 'adopted' }), 'voting', makeCtx())
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason.length).toBeGreaterThan(0)
|
||||
})
|
||||
|
||||
it('rejected est terminal — aucune sortie', () => {
|
||||
expect(canTransition(makeDecision({ status: 'rejected' }), 'adopted', makeCtx()).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('draft → advice existe', () => {
|
||||
const decision = makeDecision({ status: 'draft', route: 'advice' })
|
||||
expect(canTransition(decision, 'advice', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('le retour explicite d’une fenêtre à son propre état est permis', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate' })
|
||||
expect(canTransition(decision, 'objection', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('un état hors fenêtre ne boucle pas sur lui-même', () => {
|
||||
expect(canTransition(makeDecision({ status: 'voting' }), 'voting', makeCtx()).ok).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde b — la frontière contestée suspend toute sortie', () => {
|
||||
it('une fenêtre d’objection suspendue ne peut pas adopter', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', windowSuspendedAt: NOW })
|
||||
const result = canTransition(decision, 'adopted', makeCtx())
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('frontière')
|
||||
})
|
||||
|
||||
it('une fenêtre d’avis suspendue ne peut pas non plus escalader vers le vote', () => {
|
||||
const decision = makeDecision({ status: 'advice', route: 'advice', windowSuspendedAt: NOW })
|
||||
expect(canTransition(decision, 'voting', makeCtx()).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('le retour explicite au même état reste possible pendant la suspension', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', windowSuspendedAt: NOW })
|
||||
expect(canTransition(decision, 'objection', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('sans suspension, la fenêtre s’adopte normalement', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate' })
|
||||
expect(canTransition(decision, 'adopted', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('la frontière prime sur l’affluence (ordre des gardes)', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', windowSuspendedAt: NOW })
|
||||
const result = canTransition(decision, 'adopted', makeCtx({ concerns: influxConcerns() }))
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('frontière')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde c — l’affluence exige un traitement du périmètre', () => {
|
||||
it('ratio atteint sans scopeKeptNote — la session ne se clôt pas', () => {
|
||||
const decision = makeDecision({ status: 'voting' })
|
||||
const result = canTransition(decision, 'adopted', makeCtx({ concerns: influxConcerns() }))
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) {
|
||||
expect(result.reason).toBe(
|
||||
'Le périmètre déborde — élargis d’un cran ou motive publiquement son maintien.',
|
||||
)
|
||||
}
|
||||
})
|
||||
|
||||
it('le maintien motivé publiquement (scopeKeptNote) débloque la clôture', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'voting',
|
||||
scopeKeptNote: 'Le cercle Ateliers reste le bon périmètre : le budget est le sien.',
|
||||
})
|
||||
expect(canTransition(decision, 'adopted', makeCtx({ concerns: influxConcerns() })).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('sous le ratio, la clôture passe', () => {
|
||||
const concerns = [
|
||||
makeConcern('computed'),
|
||||
makeConcern('computed'),
|
||||
makeConcern('computed'),
|
||||
makeConcern('computed'),
|
||||
makeConcern('declared'),
|
||||
]
|
||||
const decision = makeDecision({ status: 'voting' })
|
||||
expect(canTransition(decision, 'adopted', makeCtx({ concerns })).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('sans concerné calculé, la garde ne se déclenche jamais', () => {
|
||||
const concerns = [makeConcern('declared'), makeConcern('declared'), makeConcern('declared')]
|
||||
const decision = makeDecision({ status: 'voting' })
|
||||
expect(canTransition(decision, 'adopted', makeCtx({ concerns })).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('la garde vaut aussi pour la fenêtre d’avis', () => {
|
||||
const decision = makeDecision({ status: 'advice', route: 'advice' })
|
||||
expect(canTransition(decision, 'adopted', makeCtx({ concerns: influxConcerns() })).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('la garde vaut pour le rejet d’un vote — clore, c’est clore', () => {
|
||||
const decision = makeDecision({ status: 'voting' })
|
||||
expect(canTransition(decision, 'rejected', makeCtx({ concerns: influxConcerns() })).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('les concernés d’une autre décision ne comptent pas', () => {
|
||||
const concerns = influxConcerns().map((concern) => ({ ...concern, decisionId: 'dec-2' }))
|
||||
const decision = makeDecision({ status: 'voting' })
|
||||
expect(canTransition(decision, 'adopted', makeCtx({ concerns })).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('l’escalade vers framing ou voting reste ouverte — c’est le traitement, pas la clôture', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate' })
|
||||
expect(canTransition(decision, 'framing', makeCtx({ concerns: influxConcerns() })).ok).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde d — la matière (requireEffects) à l’ouverture de session collective', () => {
|
||||
const resources = { note: 'Deux heures par semaine pendant un mois' }
|
||||
|
||||
it('« binding » + poids binding sans effet recherché — refus', () => {
|
||||
const decision = makeDecision({ status: 'draft', weight: 'binding', resources })
|
||||
const result = canTransition(decision, 'voting', makeCtx())
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('effet recherché')
|
||||
})
|
||||
|
||||
it('« binding » + poids binding avec un effet recherché — ouverture', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'draft',
|
||||
weight: 'binding',
|
||||
resources,
|
||||
brief: { effects: [{ label: 'Réduire le temps de réunion' }] },
|
||||
})
|
||||
expect(canTransition(decision, 'voting', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('« binding » + poids structural sans cible mesurable — refus', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'draft',
|
||||
weight: 'structural',
|
||||
resources,
|
||||
brief: { effects: [{ label: 'Assainir le budget' }] },
|
||||
})
|
||||
const result = canTransition(decision, 'voting', makeCtx())
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('cible')
|
||||
})
|
||||
|
||||
it('« binding » + poids structural avec une cible — ouverture', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'draft',
|
||||
weight: 'structural',
|
||||
resources,
|
||||
brief: { effects: [{ label: 'Assainir le budget', target: '≤ 400 € par mois' }] },
|
||||
})
|
||||
expect(canTransition(decision, 'voting', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('« structural » : le poids binding n’est pas sous garde', () => {
|
||||
const decision = makeDecision({ status: 'draft', weight: 'binding', resources })
|
||||
const ctx = makeCtx({ settings: makeSettings({ requireEffects: 'structural' }) })
|
||||
expect(canTransition(decision, 'voting', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('« structural » : le poids structural sans effet est refusé', () => {
|
||||
const decision = makeDecision({ status: 'draft', weight: 'structural', resources })
|
||||
const ctx = makeCtx({ settings: makeSettings({ requireEffects: 'structural' }) })
|
||||
expect(canTransition(decision, 'voting', ctx).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('« none » : aucune exigence de matière, même structural', () => {
|
||||
const decision = makeDecision({ status: 'draft', weight: 'structural', resources })
|
||||
const ctx = makeCtx({ settings: makeSettings({ requireEffects: 'none' }) })
|
||||
expect(canTransition(decision, 'voting', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('le poids light n’est jamais soumis à la matière', () => {
|
||||
const decision = makeDecision({ status: 'draft', weight: 'light' })
|
||||
expect(canTransition(decision, 'voting', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('la garde est réservée à la route collective', () => {
|
||||
const decision = makeDecision({ status: 'draft', route: 'mandate', weight: 'binding', resources })
|
||||
expect(canTransition(decision, 'voting', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('framing → voting est gardé de la même façon', () => {
|
||||
const decision = makeDecision({ status: 'framing', weight: 'structural', resources })
|
||||
expect(canTransition(decision, 'voting', makeCtx()).ok).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde e — « Ce que ça engage » à l’ouverture de fenêtre ou de session', () => {
|
||||
it('poids binding sans note de ressources — la fenêtre d’objection ne s’ouvre pas', () => {
|
||||
const decision = makeDecision({ status: 'draft', route: 'mandate', weight: 'binding' })
|
||||
const result = canTransition(decision, 'objection', makeCtx())
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('engage')
|
||||
})
|
||||
|
||||
it('avec la note, la fenêtre s’ouvre', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'draft',
|
||||
route: 'mandate',
|
||||
weight: 'binding',
|
||||
resources: { note: 'Une demi-journée de l’équipe accueil' },
|
||||
})
|
||||
expect(canTransition(decision, 'objection', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('une note blanche ne compte pas', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'draft',
|
||||
route: 'mandate',
|
||||
weight: 'binding',
|
||||
resources: { note: ' ' },
|
||||
})
|
||||
expect(canTransition(decision, 'objection', makeCtx()).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('le poids light ouvre sans note', () => {
|
||||
const decision = makeDecision({ status: 'draft', route: 'advice', weight: 'light' })
|
||||
expect(canTransition(decision, 'advice', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('la route solo est exemptée', () => {
|
||||
const decision = makeDecision({ status: 'draft', route: 'solo', weight: 'binding' })
|
||||
expect(canTransition(decision, 'advice', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('la garde vit aussi à l’ouverture de session — après la matière', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'draft',
|
||||
weight: 'binding',
|
||||
brief: { effects: [{ label: 'Un effet recherché' }] },
|
||||
})
|
||||
const result = canTransition(decision, 'voting', makeCtx())
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('engage')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde f — l’accord explicite (Assent) hors du réversible', () => {
|
||||
it('easy : le silence vaut accord, la fenêtre s’adopte sans Assent', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'easy' })
|
||||
expect(canTransition(decision, 'adopted', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('costly sans Assent — la fenêtre se prolonge', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'costly' })
|
||||
const result = canTransition(decision, 'adopted', makeCtx())
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) {
|
||||
expect(result.reason).toBe('Il manque un accord explicite — la fenêtre se prolonge.')
|
||||
}
|
||||
})
|
||||
|
||||
it('costly : l’accord de l’auteur seul ne suffit pas', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'costly' })
|
||||
const ctx = makeCtx({ assents: [makeAssent('p-author')] })
|
||||
expect(canTransition(decision, 'adopted', ctx).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('costly : un accord d’un tiers concerné débloque l’adoption', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'costly' })
|
||||
const ctx = makeCtx({ assents: [makeAssent('p-other')] })
|
||||
expect(canTransition(decision, 'adopted', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('irreversible sans Assent — refus aussi', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'objection',
|
||||
route: 'mandate',
|
||||
reversibility: 'irreversible',
|
||||
})
|
||||
expect(canTransition(decision, 'adopted', makeCtx()).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('l’Assent d’une autre décision ne compte pas', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'costly' })
|
||||
const ctx = makeCtx({ assents: [makeAssent('p-other', { decisionId: 'dec-2' })] })
|
||||
expect(canTransition(decision, 'adopted', ctx).ok).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde g — jamais d’adoption sur une objection ouverte', () => {
|
||||
it('une objection ouverte bloque l’adoption, même en easy', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'easy' })
|
||||
const result = canTransition(decision, 'adopted', makeCtx({ objections: [makeObjection('open')] }))
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('objection')
|
||||
})
|
||||
|
||||
it('une objection retirée ne bloque plus', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'easy' })
|
||||
const ctx = makeCtx({ objections: [makeObjection('withdrawn')] })
|
||||
expect(canTransition(decision, 'adopted', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('une objection intégrée ne bloque plus', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'easy' })
|
||||
const ctx = makeCtx({ objections: [makeObjection('integrated')] })
|
||||
expect(canTransition(decision, 'adopted', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('l’Assent d’un tiers ne contourne pas une objection ouverte', () => {
|
||||
const decision = makeDecision({ status: 'objection', route: 'mandate', reversibility: 'costly' })
|
||||
const ctx = makeCtx({ assents: [makeAssent('p-other')], objections: [makeObjection('open')] })
|
||||
const result = canTransition(decision, 'adopted', ctx)
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('objection')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde h — la clôture du dossier découpé', () => {
|
||||
const parent = () => makeDecision({ id: 'dossier-1', status: 'framing' })
|
||||
|
||||
function element(status: Decision['status'], overrides: Partial<Decision> = {}): Decision {
|
||||
const entity = makeEntity()
|
||||
return makeDecision({
|
||||
id: entity.id,
|
||||
parentDecisionId: 'dossier-1',
|
||||
chainKind: 'element',
|
||||
status,
|
||||
...overrides,
|
||||
})
|
||||
}
|
||||
|
||||
it('sans élément, le dossier ne se clôt pas', () => {
|
||||
const result = canTransition(parent(), 'closed', makeCtx({ children: [] }))
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('dossier')
|
||||
})
|
||||
|
||||
it('tous les éléments terminaux — le garant peut clore', () => {
|
||||
const children = [
|
||||
element('adopted'),
|
||||
element('rejected'),
|
||||
element('revoked'),
|
||||
element('closed'),
|
||||
element('transmitted'),
|
||||
]
|
||||
expect(canTransition(parent(), 'closed', makeCtx({ children })).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('un élément encore en vote retient le dossier', () => {
|
||||
const children = [element('adopted'), element('voting')]
|
||||
const result = canTransition(parent(), 'closed', makeCtx({ children }))
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) expect(result.reason).toContain('en cours')
|
||||
})
|
||||
|
||||
it('des enfants non-éléments ne font pas un dossier', () => {
|
||||
const children = [element('adopted', { chainKind: 'revision' })]
|
||||
expect(canTransition(parent(), 'closed', makeCtx({ children })).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('l’élément d’un autre dossier ne compte pas', () => {
|
||||
const children = [element('adopted', { parentDecisionId: 'dossier-2' })]
|
||||
expect(canTransition(parent(), 'closed', makeCtx({ children })).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('framing → voting du parent reste possible pendant que le dossier vit', () => {
|
||||
const decision = makeDecision({ id: 'dossier-1', status: 'framing', weight: 'light' })
|
||||
expect(canTransition(decision, 'voting', makeCtx({ children: [element('voting')] })).ok).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Garde i — la cristallisation attend le geste du garant', () => {
|
||||
const parametricDecision = () => makeDecision({ status: 'voting', paramSpec: PARAM_SPEC })
|
||||
|
||||
it('session figée — pas d’adoption sans le geste', () => {
|
||||
const ctx = makeCtx({ session: makeSession({ status: 'frozen' }) })
|
||||
const result = canTransition(parametricDecision(), 'adopted', ctx)
|
||||
expect(result.ok).toBe(false)
|
||||
if (!result.ok) {
|
||||
expect(result.reason).toBe('Les votes sont figés — la cristallisation attend son geste.')
|
||||
}
|
||||
})
|
||||
|
||||
it('session close sans crystallizedById — le moteur ne cristallise jamais', () => {
|
||||
const ctx = makeCtx({ session: makeSession({ status: 'closed' }) })
|
||||
expect(canTransition(parametricDecision(), 'adopted', ctx).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('session close et geste daté — l’adoption passe', () => {
|
||||
const ctx = makeCtx({
|
||||
session: makeSession({ status: 'closed', crystallizedById: 'p-steward', crystallizedAt: NOW }),
|
||||
})
|
||||
expect(canTransition(parametricDecision(), 'adopted', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('le rejet (quorum non atteint) exige le même geste', () => {
|
||||
const ctx = makeCtx({ session: makeSession({ status: 'frozen' }) })
|
||||
expect(canTransition(parametricDecision(), 'rejected', ctx).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('le rejet constaté au geste passe', () => {
|
||||
const ctx = makeCtx({
|
||||
session: makeSession({ status: 'closed', crystallizedById: 'p-steward', crystallizedAt: NOW }),
|
||||
})
|
||||
expect(canTransition(parametricDecision(), 'rejected', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('une session figée trahit le paramétrique même sans paramSpec', () => {
|
||||
const decision = makeDecision({ status: 'voting' })
|
||||
const ctx = makeCtx({ session: makeSession({ status: 'frozen' }) })
|
||||
expect(canTransition(decision, 'adopted', ctx).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('une session non paramétrique se clôt automatiquement — pas de geste exigé', () => {
|
||||
const decision = makeDecision({ status: 'voting' })
|
||||
const ctx = makeCtx({ session: makeSession({ status: 'closed' }) })
|
||||
expect(canTransition(decision, 'adopted', ctx).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('sans session dans le contexte, la garde ne s’applique pas', () => {
|
||||
expect(canTransition(makeDecision({ status: 'voting' }), 'adopted', makeCtx()).ok).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('windowOutcome — l’échéance des fenêtres d’objection', () => {
|
||||
it('easy — le silence vaut accord, la fenêtre s’adopte', () => {
|
||||
const decision = makeDecision({ status: 'objection', reversibility: 'easy' })
|
||||
expect(windowOutcome(decision, makeCtx())).toBe('adopt')
|
||||
})
|
||||
|
||||
it('costly sans accord tiers — la fenêtre se prolonge d’un cran', () => {
|
||||
const decision = makeDecision({ status: 'objection', reversibility: 'costly' })
|
||||
expect(windowOutcome(decision, makeCtx())).toBe('extend')
|
||||
})
|
||||
|
||||
it('costly avec l’accord d’un tiers — la fenêtre s’adopte', () => {
|
||||
const decision = makeDecision({ status: 'objection', reversibility: 'costly' })
|
||||
expect(windowOutcome(decision, makeCtx({ assents: [makeAssent('p-other')] }))).toBe('adopt')
|
||||
})
|
||||
|
||||
it('l’accord de l’auteur seul ne compte pas', () => {
|
||||
const decision = makeDecision({ status: 'objection', reversibility: 'costly' })
|
||||
expect(windowOutcome(decision, makeCtx({ assents: [makeAssent('p-author')] }))).toBe('extend')
|
||||
})
|
||||
|
||||
it('frontière suspendue — la fenêtre attend, même en easy', () => {
|
||||
const decision = makeDecision({
|
||||
status: 'objection',
|
||||
reversibility: 'easy',
|
||||
windowSuspendedAt: NOW,
|
||||
})
|
||||
expect(windowOutcome(decision, makeCtx())).toBe('wait')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,608 @@
|
||||
/**
|
||||
* Tests du moteur de routage — « Le chemin ».
|
||||
* Ordre des règles vérifié : R-U, R0a, R0b, R0c, R2, R3, R4, R5, R6.
|
||||
* Fonctions pures : fixtures assemblées à la main, aucun store.
|
||||
*/
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { detectParametricHint, triage } from '../../app/engine/triage'
|
||||
import {
|
||||
BINARY_COST,
|
||||
PARAMETRIC_ALT,
|
||||
RECORD_ALT,
|
||||
URGENT_REFUSED,
|
||||
} from '../../app/lexicon'
|
||||
import type {
|
||||
Clause,
|
||||
CollectiveSettings,
|
||||
Mandate,
|
||||
TriageContext,
|
||||
TriageInput,
|
||||
} from '../../app/types/domain'
|
||||
|
||||
const T0 = '2026-01-01T00:00:00Z'
|
||||
const T9 = '2027-01-01T00:00:00Z'
|
||||
|
||||
function mkSettings(over: {
|
||||
triage?: Partial<CollectiveSettings['triage']>
|
||||
protocolByRange?: Partial<CollectiveSettings['protocolByRange']>
|
||||
} = {}): CollectiveSettings {
|
||||
return {
|
||||
triage: {
|
||||
smallGroupMax: 5,
|
||||
collectiveMin: 50,
|
||||
consentMax: 7,
|
||||
objectionWindowHours: 48,
|
||||
adviceWindowHours: 72,
|
||||
framingDays: 14,
|
||||
concernEscalateRatio: 0.5,
|
||||
recurrenceThreshold: 3,
|
||||
reviewDelayDays: 90,
|
||||
requireEffects: 'binding',
|
||||
...over.triage,
|
||||
},
|
||||
protocolByRange: { consent: 'proto-consent', ...over.protocolByRange },
|
||||
}
|
||||
}
|
||||
|
||||
function mkInput(over: Partial<TriageInput> = {}): TriageInput {
|
||||
return {
|
||||
title: 'Repeindre la salle',
|
||||
tags: [],
|
||||
scope: { selfOnly: false, circleIds: [], personIds: [] },
|
||||
reversibility: 'costly',
|
||||
weight: 'light',
|
||||
urgent: false,
|
||||
...over,
|
||||
}
|
||||
}
|
||||
|
||||
function mkCtx(over: Partial<TriageContext> = {}): TriageContext {
|
||||
return {
|
||||
myActiveMandates: [],
|
||||
otherActiveMandates: [],
|
||||
matchingClauses: [],
|
||||
similarRecentCount: 0,
|
||||
similarRecordedCount: 0,
|
||||
computedConcernedIds: ['p1', 'p2', 'p3'],
|
||||
...over,
|
||||
}
|
||||
}
|
||||
|
||||
function mkMandate(over: Partial<Mandate> = {}): Mandate {
|
||||
return {
|
||||
id: 'm1',
|
||||
collectiveId: 'col',
|
||||
createdAt: T0,
|
||||
updatedAt: T0,
|
||||
title: 'Modération',
|
||||
holderId: 'p-holder',
|
||||
originDecisionId: 'd0',
|
||||
domain: { circleIds: ['c1', 'c2'], tags: [] },
|
||||
startsAt: T0,
|
||||
endsAt: T9,
|
||||
electorCircleId: 'c1',
|
||||
nominationMethod: 'consent',
|
||||
reports: [],
|
||||
status: 'active',
|
||||
...over,
|
||||
}
|
||||
}
|
||||
|
||||
function mkClause(over: Partial<Clause> = {}): Clause {
|
||||
return {
|
||||
id: 'cl1',
|
||||
collectiveId: 'col',
|
||||
createdAt: T0,
|
||||
updatedAt: T0,
|
||||
docId: 'doc1',
|
||||
section: 'E',
|
||||
position: 9,
|
||||
code: 'E9',
|
||||
title: 'Acte Forgeron',
|
||||
inertia: 'high',
|
||||
...over,
|
||||
}
|
||||
}
|
||||
|
||||
const scoped = (circleIds: string[]): TriageInput['scope'] =>
|
||||
({ selfOnly: false, circleIds, personIds: [] })
|
||||
|
||||
describe('detectParametricHint — nombre, %, montant dans la phrase', () => {
|
||||
it('détecte un montant en euros', () => {
|
||||
expect(detectParametricHint('Fixer la cotisation à 25 €')).toBe(true)
|
||||
})
|
||||
|
||||
it('ne détecte rien dans une phrase sans chiffre', () => {
|
||||
expect(detectParametricHint('Repeindre la salle')).toBe(false)
|
||||
})
|
||||
|
||||
it('détecte un pourcentage', () => {
|
||||
expect(detectParametricHint('Porter la part commune à douze %')).toBe(true)
|
||||
})
|
||||
|
||||
it('détecte l\'unité DU en majuscules', () => {
|
||||
expect(detectParametricHint('Verser un DU aux nouveaux venus')).toBe(true)
|
||||
})
|
||||
|
||||
it('ne confond pas l\'article « du » avec l\'unité DU', () => {
|
||||
expect(detectParametricHint('Changer du mobilier dans la salle')).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('R-U — urgence', () => {
|
||||
it('conservatoire : route sous-jacente calculée sans urgence, fenêtre doublée, chaîne posée', () => {
|
||||
// Sans urgence, ce cas serait R4 (easy, 3 ≤ 5, fenêtre 72 h).
|
||||
const verdict = triage(
|
||||
mkInput({ urgent: true, reversibility: 'easy' }),
|
||||
mkCtx(),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R-U')
|
||||
expect(verdict.route).toBe('advice')
|
||||
expect(verdict.conservatoryChain).toBe(true)
|
||||
expect(verdict.windowHours).toBe(144)
|
||||
expect(verdict.explanation).toBe('Décidé en urgence — le collectif ratifie.')
|
||||
})
|
||||
|
||||
it('urgence × irréversible : refus — route normale, fenêtres minimales (jamais doublées)', () => {
|
||||
// Sans urgence, ce cas serait R0b (mandat couvrant, fenêtre 48 h).
|
||||
const verdict = triage(
|
||||
mkInput({ urgent: true, reversibility: 'irreversible', scope: scoped(['c1']) }),
|
||||
mkCtx({ myActiveMandates: [mkMandate()] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R-U')
|
||||
expect(verdict.route).toBe('mandate')
|
||||
expect(verdict.explanation).toBe(URGENT_REFUSED)
|
||||
expect(verdict.conservatoryChain).toBeUndefined()
|
||||
expect(verdict.windowHours).toBe(48)
|
||||
})
|
||||
})
|
||||
|
||||
describe('R0a — déjà décidé', () => {
|
||||
it('clause en vigueur trouvée : consigner en principal, agir ou contester', () => {
|
||||
const verdict = triage(mkInput(), mkCtx({ matchingClauses: [mkClause()] }), mkSettings())
|
||||
|
||||
expect(verdict.rule).toBe('R0a')
|
||||
expect(verdict.route).toBe('record')
|
||||
expect(verdict.explanation).toBe(
|
||||
'C\'est déjà décidé (E9, Acte Forgeron) — agis, ou conteste la règle.',
|
||||
)
|
||||
expect(verdict.windowHours).toBeUndefined()
|
||||
})
|
||||
|
||||
it('limite : viser explicitement la clause (amendsClauseId) passe à R3, pas R0a', () => {
|
||||
// Choix documenté : contester la règle EST R3 — R0a ne bloque pas l'amendement.
|
||||
const verdict = triage(
|
||||
mkInput({ amendsClauseId: 'cl1' }),
|
||||
mkCtx({ matchingClauses: [mkClause()] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R3')
|
||||
expect(verdict.route).toBe('collective')
|
||||
})
|
||||
})
|
||||
|
||||
describe('R0b — mon mandat couvre', () => {
|
||||
it('périmètre inclus dans le domaine du mandat : décide, c\'est tracé', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: scoped(['c1']) }),
|
||||
mkCtx({ myActiveMandates: [mkMandate()] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R0b')
|
||||
expect(verdict.route).toBe('mandate')
|
||||
expect(verdict.windowHours).toBe(48)
|
||||
expect(verdict.explanation).toBe('Ton mandat Modération couvre — décide, c\'est tracé.')
|
||||
})
|
||||
|
||||
it('limite : couverture partielle du périmètre ne suffit pas', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: scoped(['c1', 'c3']) }),
|
||||
mkCtx({ myActiveMandates: [mkMandate({ domain: { circleIds: ['c1', 'c2'], tags: [] } })] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).not.toBe('R0b')
|
||||
})
|
||||
|
||||
it('ordre : selfOnly avec mandat couvrant ⇒ R0b gagne, car R0b précède R2', () => {
|
||||
// Choix documenté : le devoir de trace du mandat prime sur le solo.
|
||||
const verdict = triage(
|
||||
mkInput({ scope: { selfOnly: true, circleIds: ['c1'], personIds: [] } }),
|
||||
mkCtx({ myActiveMandates: [mkMandate()] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R0b')
|
||||
expect(verdict.route).toBe('mandate')
|
||||
})
|
||||
|
||||
it('limite : périmètre sans cercle ⇒ jamais de couverture triviale', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: scoped([]) }),
|
||||
mkCtx({ myActiveMandates: [mkMandate()] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).not.toBe('R0b')
|
||||
})
|
||||
})
|
||||
|
||||
describe('R0c — le mandat d\'un autre couvre', () => {
|
||||
it('transmets à sa ou son titulaire — le titre du mandat nomme le pouvoir', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: scoped(['c1']) }),
|
||||
mkCtx({ otherActiveMandates: [mkMandate({ holderId: 'p-other' })] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R0c')
|
||||
expect(verdict.route).toBe('transmit')
|
||||
expect(verdict.explanation).toBe(
|
||||
'Le mandat Modération couvre — transmets à sa ou son titulaire.',
|
||||
)
|
||||
})
|
||||
|
||||
it('ordre : mon mandat gagne sur celui d\'un autre (R0b avant R0c)', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: scoped(['c1']) }),
|
||||
mkCtx({
|
||||
myActiveMandates: [mkMandate({ id: 'm-me', title: 'Trésorerie' })],
|
||||
otherActiveMandates: [mkMandate({ id: 'm-other', holderId: 'p-other' })],
|
||||
}),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R0b')
|
||||
})
|
||||
|
||||
it('limite : un mandat expiré ne couvre pas', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: scoped(['c1']) }),
|
||||
mkCtx({ otherActiveMandates: [mkMandate({ status: 'expired' })] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).not.toBe('R0c')
|
||||
})
|
||||
})
|
||||
|
||||
describe('R2 — moi seul', () => {
|
||||
it('selfOnly : décide, zéro fenêtre', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: { selfOnly: true, circleIds: [], personIds: [] } }),
|
||||
mkCtx({ computedConcernedIds: [] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R2')
|
||||
expect(verdict.route).toBe('solo')
|
||||
expect(verdict.explanation).toBe('Personne d\'autre n\'est concerné — décide.')
|
||||
expect(verdict.windowHours).toBeUndefined()
|
||||
expect(verdict.reviewRequired).toBe(false)
|
||||
})
|
||||
|
||||
it('limite : irréversible sur soi ⇒ revoyure suggérée (pré-coche retirable côté UI)', () => {
|
||||
// Le moteur suggère (reviewRequired) ; la pré-coche retirable est un fait
|
||||
// d'UI — sur soi, l'outil ne s'interpose jamais.
|
||||
const verdict = triage(
|
||||
mkInput({
|
||||
scope: { selfOnly: true, circleIds: [], personIds: [] },
|
||||
reversibility: 'irreversible',
|
||||
}),
|
||||
mkCtx({ computedConcernedIds: [] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R2')
|
||||
expect(verdict.reviewRequired).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('R3 — clause visée', () => {
|
||||
const clauseSettings = mkSettings({
|
||||
protocolByRange: {
|
||||
clauseByInertia: {
|
||||
low: 'proto-low',
|
||||
standard: 'proto-standard',
|
||||
high: 'proto-high',
|
||||
max: 'proto-max',
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
it('l\'inertie de la clause choisit le protocole', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ amendsClauseId: 'cl1' }),
|
||||
mkCtx({ matchingClauses: [mkClause({ inertia: 'high' })] }),
|
||||
clauseSettings,
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R3')
|
||||
expect(verdict.route).toBe('collective')
|
||||
expect(verdict.protocolId).toBe('proto-high')
|
||||
expect(verdict.explanation).toBe(
|
||||
'Tu proposes une version de E9 — son inertie s\'applique : vote de ceux qu\'elle gouverne.',
|
||||
)
|
||||
})
|
||||
|
||||
it('repli : sans clauseByInertia, le consentement s\'applique', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ amendsClauseId: 'cl1' }),
|
||||
mkCtx({ matchingClauses: [mkClause()] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.protocolId).toBe('proto-consent')
|
||||
})
|
||||
|
||||
it('poids structurel ⇒ fenêtre de formulation posée', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ amendsClauseId: 'cl1', weight: 'structural' }),
|
||||
mkCtx({ matchingClauses: [mkClause()] }),
|
||||
clauseSettings,
|
||||
)
|
||||
|
||||
expect(verdict.framingDays).toBe(14)
|
||||
})
|
||||
|
||||
it('limite : clause introuvable dans l\'index ⇒ consentement et phrase générique', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ amendsClauseId: 'cl-inconnue' }),
|
||||
mkCtx({ matchingClauses: [] }),
|
||||
clauseSettings,
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R3')
|
||||
expect(verdict.protocolId).toBe('proto-consent')
|
||||
expect(verdict.explanation).toBe(
|
||||
'Tu proposes une version de cette règle — son inertie s\'applique : vote de ceux qu\'elle gouverne.',
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
describe('R4 — petit cercle réversible', () => {
|
||||
it('réversible et 3 personnes : demande leur avis puis décide (72 h)', () => {
|
||||
const verdict = triage(mkInput({ reversibility: 'easy' }), mkCtx(), mkSettings())
|
||||
|
||||
expect(verdict.rule).toBe('R4')
|
||||
expect(verdict.route).toBe('advice')
|
||||
expect(verdict.windowHours).toBe(72)
|
||||
expect(verdict.explanation).toBe(
|
||||
'Réversible et 3 personnes concernées — demande leur avis puis décide.',
|
||||
)
|
||||
})
|
||||
|
||||
it('limite : accord du singulier pour 1 personne', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ reversibility: 'easy' }),
|
||||
mkCtx({ computedConcernedIds: ['p1'] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.explanation).toBe(
|
||||
'Réversible et 1 personne concernée — demande leur avis puis décide.',
|
||||
)
|
||||
})
|
||||
|
||||
it('limite : au-delà de smallGroupMax, l\'escalade collective s\'applique', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ reversibility: 'easy' }),
|
||||
mkCtx({ computedConcernedIds: ['p1', 'p2', 'p3', 'p4', 'p5', 'p6'] }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R5')
|
||||
})
|
||||
|
||||
it('limite : coûteux à défaire ⇒ jamais R4, même à 3 personnes', () => {
|
||||
const verdict = triage(mkInput({ reversibility: 'costly' }), mkCtx(), mkSettings())
|
||||
|
||||
expect(verdict.rule).toBe('R5')
|
||||
})
|
||||
})
|
||||
|
||||
describe('R5 — collectif, modalité par taille du périmètre', () => {
|
||||
const ids = (n: number): string[] => Array.from({ length: n }, (_, i) => `p${i}`)
|
||||
const fullSettings = mkSettings({
|
||||
protocolByRange: { nuanced: 'proto-nuanced', large: 'proto-large' },
|
||||
})
|
||||
|
||||
it('n ≤ consentMax : un tour d\'accord suffit', () => {
|
||||
const verdict = triage(
|
||||
mkInput(),
|
||||
mkCtx({ computedConcernedIds: ids(6) }),
|
||||
fullSettings,
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R5')
|
||||
expect(verdict.route).toBe('collective')
|
||||
expect(verdict.protocolId).toBe('proto-consent')
|
||||
expect(verdict.explanation).toBe(
|
||||
'Vous êtes 6 — un tour d\'accord suffit : sans objection, c\'est adopté.',
|
||||
)
|
||||
})
|
||||
|
||||
it('n ≤ collectiveMin : vote nuancé', () => {
|
||||
const verdict = triage(
|
||||
mkInput(),
|
||||
mkCtx({ computedConcernedIds: ids(23) }),
|
||||
fullSettings,
|
||||
)
|
||||
|
||||
expect(verdict.protocolId).toBe('proto-nuanced')
|
||||
expect(verdict.explanation).toBe(
|
||||
'Vous êtes 23 — vote nuancé : chacun se prononce en nuances, pas en camps.',
|
||||
)
|
||||
})
|
||||
|
||||
it('repli : sans protocole nuancé, le consentement s\'applique', () => {
|
||||
const verdict = triage(mkInput(), mkCtx({ computedConcernedIds: ids(23) }), mkSettings())
|
||||
|
||||
expect(verdict.protocolId).toBe('proto-consent')
|
||||
})
|
||||
|
||||
it('n > collectiveMin : la modalité choisie par le Pacte', () => {
|
||||
const verdict = triage(
|
||||
mkInput(),
|
||||
mkCtx({ computedConcernedIds: ids(60) }),
|
||||
fullSettings,
|
||||
)
|
||||
|
||||
expect(verdict.protocolId).toBe('proto-large')
|
||||
expect(verdict.explanation).toBe(
|
||||
'Vous êtes 60 — la modalité que votre Pacte a choisie s\'applique.',
|
||||
)
|
||||
})
|
||||
|
||||
it('repli : sans protocole large, le consentement s\'applique', () => {
|
||||
const verdict = triage(mkInput(), mkCtx({ computedConcernedIds: ids(60) }), mkSettings())
|
||||
|
||||
expect(verdict.protocolId).toBe('proto-consent')
|
||||
})
|
||||
|
||||
it('poids structurel ⇒ formulation + revoyure + gravure suggérée', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ weight: 'structural' }),
|
||||
mkCtx({ computedConcernedIds: ids(6) }),
|
||||
fullSettings,
|
||||
)
|
||||
|
||||
expect(verdict.framingDays).toBe(14)
|
||||
expect(verdict.reviewRequired).toBe(true)
|
||||
expect(verdict.engravingSuggested).toBe(true)
|
||||
})
|
||||
|
||||
it('irréversible ⇒ revoyure exigée, sans gravure automatique', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ reversibility: 'irreversible' }),
|
||||
mkCtx({ computedConcernedIds: ids(6) }),
|
||||
fullSettings,
|
||||
)
|
||||
|
||||
expect(verdict.reviewRequired).toBe(true)
|
||||
expect(verdict.engravingSuggested).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('R6 — récurrence et maturation (surcouche, jamais bloquante)', () => {
|
||||
it('3 décisions similaires récentes ⇒ suggère de réclamer un mandat, sans changer la route', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ tags: ['cuisine', 'achats'] }),
|
||||
mkCtx({ similarRecentCount: 3 }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R5')
|
||||
expect(verdict.suggestion?.kind).toBe('claim-mandate')
|
||||
})
|
||||
|
||||
it('3 consignations similaires ⇒ suggère de protocoliser la pratique', () => {
|
||||
const verdict = triage(mkInput(), mkCtx({ similarRecordedCount: 3 }), mkSettings())
|
||||
|
||||
expect(verdict.suggestion?.kind).toBe('protocolize')
|
||||
})
|
||||
|
||||
it('les deux seuils atteints ⇒ réclamer un mandat passe en premier', () => {
|
||||
const verdict = triage(
|
||||
mkInput(),
|
||||
mkCtx({ similarRecentCount: 3, similarRecordedCount: 3 }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.suggestion?.kind).toBe('claim-mandate')
|
||||
})
|
||||
|
||||
it('sous le seuil ⇒ aucune suggestion', () => {
|
||||
const verdict = triage(
|
||||
mkInput(),
|
||||
mkCtx({ similarRecentCount: 2, similarRecordedCount: 2 }),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.suggestion).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('Repli sans protocole de consentement (bundle corrompu)', () => {
|
||||
const broken = mkSettings({ protocolByRange: { consent: '' } })
|
||||
|
||||
it('route sur avis avec la bannière — prioritaire même sur un mandat couvrant', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: scoped(['c1']) }),
|
||||
mkCtx({ myActiveMandates: [mkMandate()] }),
|
||||
broken,
|
||||
)
|
||||
|
||||
expect(verdict.route).toBe('advice')
|
||||
expect(verdict.explanation).toBe('Aucun protocole — crée-le ou décide sur avis.')
|
||||
expect(verdict.windowHours).toBe(72)
|
||||
})
|
||||
|
||||
it('sauf R2 : moi seul décide sans protocole', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ scope: { selfOnly: true, circleIds: [], personIds: [] } }),
|
||||
mkCtx(),
|
||||
broken,
|
||||
)
|
||||
|
||||
expect(verdict.rule).toBe('R2')
|
||||
expect(verdict.route).toBe('solo')
|
||||
})
|
||||
|
||||
it('sauf consigner : une clause en vigueur reste consignable sans protocole', () => {
|
||||
const verdict = triage(mkInput(), mkCtx({ matchingClauses: [mkClause()] }), broken)
|
||||
|
||||
expect(verdict.rule).toBe('R0a')
|
||||
expect(verdict.route).toBe('record')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Alternatives permanentes — « Je choisis autrement »', () => {
|
||||
it('toujours présentes : réglage, consigner, binaire avec son coût', () => {
|
||||
const verdict = triage(mkInput(), mkCtx(), mkSettings())
|
||||
|
||||
expect(verdict.alternatives).toHaveLength(3)
|
||||
const labels = verdict.alternatives.map(a => a.label)
|
||||
expect(labels).toContain(PARAMETRIC_ALT)
|
||||
expect(labels).toContain(RECORD_ALT)
|
||||
const binary = verdict.alternatives.find(a => a.cost === BINARY_COST)
|
||||
expect(binary).toBeDefined()
|
||||
expect(binary?.route).toBe('collective')
|
||||
})
|
||||
|
||||
it('présentes sur toutes les routes, solo et consigner comprises', () => {
|
||||
const solo = triage(
|
||||
mkInput({ scope: { selfOnly: true, circleIds: [], personIds: [] } }),
|
||||
mkCtx(),
|
||||
mkSettings(),
|
||||
)
|
||||
const record = triage(mkInput(), mkCtx({ matchingClauses: [mkClause()] }), mkSettings())
|
||||
|
||||
expect(solo.alternatives).toHaveLength(3)
|
||||
expect(record.alternatives).toHaveLength(3)
|
||||
})
|
||||
|
||||
it('montant détecté ⇒ le réglage passe en premier et parametricHint est posé', () => {
|
||||
const verdict = triage(
|
||||
mkInput({ title: 'Fixer la cotisation à 25 €' }),
|
||||
mkCtx(),
|
||||
mkSettings(),
|
||||
)
|
||||
|
||||
expect(verdict.parametricHint).toBe(true)
|
||||
expect(verdict.alternatives[0]?.label).toBe(PARAMETRIC_ALT)
|
||||
})
|
||||
|
||||
it('sans montant ⇒ pas de mise en avant du réglage', () => {
|
||||
const verdict = triage(mkInput(), mkCtx(), mkSettings())
|
||||
|
||||
expect(verdict.parametricHint).toBeUndefined()
|
||||
expect(verdict.alternatives[0]?.label).not.toBe(PARAMETRIC_ALT)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,142 @@
|
||||
/**
|
||||
* Anti-lexicon guard (BLUEPRINT-V2.md Δ22).
|
||||
*
|
||||
* Two sweeps, both case- and accent-insensitive (NFD normalization):
|
||||
* 1. Every UI-visible VALUE exported by app/lexicon.ts — strings, Record
|
||||
* values, array items, and the return of template functions called with
|
||||
* dummy params. Export NAMES and Record KEYS are code identifiers and
|
||||
* are NOT tested (e.g. REVIEW_VERDICTS is a legal identifier even
|
||||
* though « verdict » is forbidden in UI text).
|
||||
* 2. The <template> section of every MARKED .vue file under app/.
|
||||
* A file is scanned only when it carries the magic marker comment
|
||||
* <!-- ld-v2 -->. EVERY v2 screen MUST carry this marker (the screen
|
||||
* agents add it); unmarked v1 leftovers are ignored on purpose — they
|
||||
* are scheduled for replacement, not for compliance.
|
||||
*/
|
||||
import { readdirSync, readFileSync } from 'node:fs'
|
||||
import { join } from 'node:path'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import * as lexicon from '../app/lexicon'
|
||||
import { FORBIDDEN_UI_TERMS } from '../app/lexicon'
|
||||
|
||||
const APP_DIR = fileURLToPath(new URL('../app', import.meta.url))
|
||||
|
||||
/** Lowercase + strip diacritics: « Délégué » → « delegue ». */
|
||||
function normalize(text: string): string {
|
||||
return text.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase()
|
||||
}
|
||||
|
||||
const NORMALIZED_TERMS = FORBIDDEN_UI_TERMS.map(term => ({ term, needle: normalize(term) }))
|
||||
|
||||
/** Forbidden terms contained in a text, after normalization. */
|
||||
function forbiddenTermsIn(text: string): string[] {
|
||||
const haystack = normalize(text)
|
||||
return NORMALIZED_TERMS.filter(({ needle }) => haystack.includes(needle)).map(({ term }) => term)
|
||||
}
|
||||
|
||||
interface Violation {
|
||||
source: string // export path or file path
|
||||
term: string
|
||||
excerpt: string
|
||||
}
|
||||
|
||||
/** Call a template function with dummy params (numbers interpolate cleanly
|
||||
* into template literals AND support toLocaleString; fall back to neutral
|
||||
* strings for functions that require them). */
|
||||
function callTemplateFn(fn: (...args: never[]) => unknown): unknown {
|
||||
const arity = Math.max(fn.length, 1)
|
||||
try {
|
||||
return fn(...(Array.from({ length: arity }, (_, i) => i + 1) as never[]))
|
||||
} catch {
|
||||
return fn(...(Array.from({ length: arity }, () => 'exemple') as never[]))
|
||||
}
|
||||
}
|
||||
|
||||
/** Recursively collect forbidden-term violations over exported VALUES only. */
|
||||
function walkValue(value: unknown, path: string, violations: Violation[]): void {
|
||||
if (typeof value === 'string') {
|
||||
for (const term of forbiddenTermsIn(value)) {
|
||||
violations.push({ source: path, term, excerpt: value })
|
||||
}
|
||||
return
|
||||
}
|
||||
if (Array.isArray(value)) {
|
||||
value.forEach((item, i) => walkValue(item, `${path}[${i}]`, violations))
|
||||
return
|
||||
}
|
||||
if (typeof value === 'function') {
|
||||
walkValue(callTemplateFn(value as (...args: never[]) => unknown), `${path}(…)`, violations)
|
||||
return
|
||||
}
|
||||
if (value !== null && typeof value === 'object') {
|
||||
// Record: VALUES only — keys are code identifiers.
|
||||
for (const [key, item] of Object.entries(value)) {
|
||||
walkValue(item, `${path}.${key}`, violations)
|
||||
}
|
||||
}
|
||||
// numbers / booleans / null / undefined: nothing to check
|
||||
}
|
||||
|
||||
/** Recursive .vue listing under dir. */
|
||||
function listVueFiles(dir: string): string[] {
|
||||
const files: string[] = []
|
||||
for (const entry of readdirSync(dir, { withFileTypes: true })) {
|
||||
const full = join(dir, entry.name)
|
||||
if (entry.isDirectory()) files.push(...listVueFiles(full))
|
||||
else if (entry.isFile() && entry.name.endsWith('.vue')) files.push(full)
|
||||
}
|
||||
return files
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan the <template> section of every .vue file under `dir` that carries
|
||||
* the magic marker comment (default <!-- ld-v2 -->). The whole template is
|
||||
* scanned on purpose — the banned vocabulary must appear NOWHERE in it,
|
||||
* bound attributes included. Every v2 screen MUST carry the marker.
|
||||
*/
|
||||
export function scanVueTemplates(dir: string, marker = 'ld-v2'): Violation[] {
|
||||
const markerRe = new RegExp(`<!--\\s*${marker}\\s*-->`)
|
||||
const violations: Violation[] = []
|
||||
for (const file of listVueFiles(dir)) {
|
||||
const content = readFileSync(file, 'utf-8')
|
||||
if (!markerRe.test(content)) continue
|
||||
const start = content.indexOf('<template')
|
||||
const end = content.lastIndexOf('</template>')
|
||||
if (start === -1 || end === -1) continue
|
||||
const template = content.slice(start, end + '</template>'.length)
|
||||
for (const term of forbiddenTermsIn(template)) {
|
||||
violations.push({ source: file, term, excerpt: `terme présent dans <template>` })
|
||||
}
|
||||
}
|
||||
return violations
|
||||
}
|
||||
|
||||
function formatReport(violations: Violation[]): string {
|
||||
return violations
|
||||
.map(v => `${v.source} → terme interdit « ${v.term} » : ${v.excerpt}`)
|
||||
.join('\n')
|
||||
}
|
||||
|
||||
describe('anti-lexique — lexicon.ts', () => {
|
||||
it('exports at least the known label tables (sanity check of the walk)', () => {
|
||||
expect(Object.keys(lexicon).length).toBeGreaterThan(10)
|
||||
expect(typeof lexicon.thresholdSentence).toBe('function')
|
||||
})
|
||||
|
||||
it('no exported UI value contains a forbidden term', () => {
|
||||
const violations: Violation[] = []
|
||||
for (const [name, value] of Object.entries(lexicon)) {
|
||||
if (name === 'FORBIDDEN_UI_TERMS') continue // the ban list itself
|
||||
walkValue(value, name, violations)
|
||||
}
|
||||
expect(formatReport(violations)).toBe('')
|
||||
})
|
||||
})
|
||||
|
||||
describe('anti-lexique — marked .vue templates (<!-- ld-v2 -->)', () => {
|
||||
it('no marked template contains a forbidden term', () => {
|
||||
const violations = scanVueTemplates(APP_DIR)
|
||||
expect(formatReport(violations)).toBe('')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,622 @@
|
||||
/**
|
||||
* Seed « Atelier du Canal » — LE test permanent de la marque blanche
|
||||
* (BLUEPRINT-V2.md § Seeds, DEUXIÈME COLLECTIF).
|
||||
*
|
||||
* Chaque état de l'UI v2 doit y trouver sa donnée vivante : tous les
|
||||
* DecisionStatus (y compris 'transmitted'), une session open ET une session
|
||||
* frozen à cristalliser, une consignation, un dossier découpé pondéré,
|
||||
* le paramétrique d'exemple calculable (validé par le moteur réel),
|
||||
* l'accord explicite (Assent), la frontière suspensive, et un Pacte à
|
||||
* seuils DIFFÉRENTS des défauts — résolu par resolveSettings.
|
||||
*
|
||||
* Repère temporel : bundle.exportedAt (2026-08-11) — les comparaisons de
|
||||
* dates sont lexicales sur ISO 8601 UTC, donc déterministes pour toujours.
|
||||
*/
|
||||
import type {
|
||||
Bundle,
|
||||
Decision,
|
||||
DecisionRoute,
|
||||
DecisionStatus,
|
||||
ParamSpec,
|
||||
Reversibility,
|
||||
TriageRule,
|
||||
Vote,
|
||||
VoteSession,
|
||||
Weight,
|
||||
} from '../../app/types/domain'
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import raw from '../../app/data/seeds/atelier-du-canal.bundle.json'
|
||||
import {
|
||||
crystallize,
|
||||
medianByElement,
|
||||
resolveDerived,
|
||||
validateParamSpec,
|
||||
validateVote,
|
||||
} from '../../app/engine/parametric'
|
||||
import { resolveSettings } from '../../app/engine/settings'
|
||||
|
||||
const bundle = raw as unknown as Bundle
|
||||
const REF = bundle.exportedAt // '2026-08-11T12:00:00.000Z'
|
||||
|
||||
const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
|
||||
const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
|
||||
|
||||
const ALL_STATUSES: DecisionStatus[] = [
|
||||
'draft', 'advice', 'objection', 'framing', 'voting',
|
||||
'adopted', 'rejected', 'revoked', 'transmitted', 'closed',
|
||||
]
|
||||
const ROUTES: DecisionRoute[] = ['solo', 'mandate', 'transmit', 'advice', 'collective', 'record']
|
||||
const REVERSIBILITIES: Reversibility[] = ['easy', 'costly', 'irreversible']
|
||||
const WEIGHTS: Weight[] = ['light', 'binding', 'structural']
|
||||
const TRIAGE_RULES: TriageRule[] = ['R-U', 'R0a', 'R0b', 'R0c', 'R2', 'R3', 'R4', 'R5', 'R6']
|
||||
|
||||
const personIds = new Set(bundle.people.map(p => p.id))
|
||||
const circleIds = new Set(bundle.circles.map(c => c.id))
|
||||
const decisionById = new Map(bundle.decisions.map(d => [d.id, d]))
|
||||
const protocolById = new Map(bundle.protocols.map(p => [p.id, p]))
|
||||
const clauseById = new Map(bundle.clauses.map(c => [c.id, c]))
|
||||
|
||||
function decision(titlePart: string): Decision {
|
||||
const found = bundle.decisions.find(d => d.title.includes(titlePart))
|
||||
expect(found, `décision « ${titlePart} » présente`).toBeDefined()
|
||||
return found as Decision
|
||||
}
|
||||
function sessionsOf(decisionId: string): VoteSession[] {
|
||||
return bundle.sessions.filter(s => s.decisionId === decisionId)
|
||||
}
|
||||
function votesOf(sessionId: string): Vote[] {
|
||||
return bundle.votes.filter(v => v.sessionId === sessionId)
|
||||
}
|
||||
|
||||
describe('socle du bundle', () => {
|
||||
it('schemaVersion 2, exportedAt, toutes les collections présentes', () => {
|
||||
expect(bundle.schemaVersion).toBe(2)
|
||||
expect(bundle.exportedAt).toMatch(ISO_RE)
|
||||
const collections = [
|
||||
'people', 'circles', 'decisions', 'concerns', 'objections', 'advices',
|
||||
'assents', 'mandates', 'docs', 'clauses', 'versions', 'protocols',
|
||||
'sessions', 'votes',
|
||||
] as const
|
||||
for (const key of collections) {
|
||||
expect(Array.isArray(bundle[key]), `${key} est un tableau`).toBe(true)
|
||||
}
|
||||
})
|
||||
|
||||
it('le collectif : slug, gabarit association, transparent, Pacte et racine reliés', () => {
|
||||
const c = bundle.collective
|
||||
expect(c.slug).toBe('atelier-du-canal')
|
||||
expect(c.template).toBe('association')
|
||||
expect(c.isTransparent).toBe(true)
|
||||
const pact = bundle.docs.find(d => d.id === c.pactDocId)
|
||||
expect(pact?.role).toBe('pact')
|
||||
expect(bundle.circles.some(circle => circle.id === c.rootCircleId)).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('identifiants et horloges', () => {
|
||||
const entities = [
|
||||
bundle.collective,
|
||||
...bundle.people, ...bundle.circles, ...bundle.decisions, ...bundle.concerns,
|
||||
...bundle.objections, ...bundle.advices, ...bundle.assents, ...bundle.mandates,
|
||||
...bundle.docs, ...bundle.clauses, ...bundle.versions, ...bundle.protocols,
|
||||
...bundle.sessions, ...bundle.votes,
|
||||
]
|
||||
|
||||
it('tous les ids sont des UUID v4-like, sans préfixe lisible, uniques', () => {
|
||||
const ids = entities.map(e => e.id)
|
||||
for (const id of ids) expect(id).toMatch(UUID_V4_RE)
|
||||
expect(new Set(ids).size).toBe(ids.length)
|
||||
})
|
||||
|
||||
it('collectiveId partout, createdAt/updatedAt partout', () => {
|
||||
for (const e of entities) {
|
||||
if (e !== bundle.collective) {
|
||||
expect((e as { collectiveId: string }).collectiveId).toBe(bundle.collective.id)
|
||||
}
|
||||
expect(e.createdAt).toMatch(ISO_RE)
|
||||
expect(e.updatedAt).toMatch(ISO_RE)
|
||||
expect(e.createdAt <= e.updatedAt).toBe(true)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('personnes et cercles', () => {
|
||||
it('12 personnes, isMe sur AUCUNE, 3-4 attributs heures/mois', () => {
|
||||
expect(bundle.people).toHaveLength(12)
|
||||
expect(bundle.people.every(p => p.isMe === false)).toBe(true)
|
||||
const withHours = bundle.people.filter(p => typeof p.attributes?.['heures/mois'] === 'number')
|
||||
expect(withHours.length).toBeGreaterThanOrEqual(3)
|
||||
expect(withHours.length).toBeLessThanOrEqual(4)
|
||||
})
|
||||
|
||||
it('cercles typés : racine complète, team ×4, theme ×7, place ×5, membres valides', () => {
|
||||
const root = bundle.circles.find(c => c.id === bundle.collective.rootCircleId)
|
||||
expect(root?.memberIds).toHaveLength(12)
|
||||
const byKind = (kind: string) => bundle.circles.filter(c => c.kind === kind)
|
||||
expect(byKind('team')).toHaveLength(1)
|
||||
expect(byKind('team')[0].memberIds).toHaveLength(4)
|
||||
expect(byKind('theme')).toHaveLength(1)
|
||||
expect(byKind('theme')[0].memberIds).toHaveLength(7)
|
||||
expect(byKind('place')).toHaveLength(1)
|
||||
expect(byKind('place')[0].memberIds).toHaveLength(5)
|
||||
for (const circle of bundle.circles) {
|
||||
for (const m of circle.memberIds) expect(personIds.has(m)).toBe(true)
|
||||
if (circle.id !== bundle.collective.rootCircleId) {
|
||||
expect(circle.parentCircleId).toBe(bundle.collective.rootCircleId)
|
||||
}
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('décisions — enums, références, couverture des états', () => {
|
||||
it('chaque décision est structurellement valide', () => {
|
||||
for (const d of bundle.decisions) {
|
||||
expect(personIds.has(d.authorId), `auteur de « ${d.title} »`).toBe(true)
|
||||
expect(ROUTES).toContain(d.route)
|
||||
expect(ALL_STATUSES).toContain(d.status)
|
||||
expect(REVERSIBILITIES).toContain(d.reversibility)
|
||||
expect(WEIGHTS).toContain(d.weight)
|
||||
expect(TRIAGE_RULES).toContain(d.triageRule)
|
||||
expect(['private', 'scope', 'collective']).toContain(d.visibility)
|
||||
expect(Array.isArray(d.tags)).toBe(true)
|
||||
expect(Array.isArray(d.stewardIds)).toBe(true)
|
||||
expect(Array.isArray(d.measurerIds)).toBe(true)
|
||||
for (const cid of d.scope.circleIds) expect(circleIds.has(cid)).toBe(true)
|
||||
for (const pid of d.scope.personIds) expect(personIds.has(pid)).toBe(true)
|
||||
if (d.parentDecisionId) {
|
||||
expect(decisionById.has(d.parentDecisionId)).toBe(true)
|
||||
expect(d.chainKind).toBeDefined()
|
||||
}
|
||||
if (d.protocolId) expect(protocolById.has(d.protocolId)).toBe(true)
|
||||
if (d.amendsClauseId) expect(clauseById.has(d.amendsClauseId)).toBe(true)
|
||||
if (d.status === 'adopted' || d.status === 'closed') {
|
||||
expect(d.decidedAt, `decidedAt de « ${d.title} »`).toBeDefined()
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
it('TOUS les DecisionStatus sont couverts, transmitted inclus', () => {
|
||||
const present = new Set(bundle.decisions.map(d => d.status))
|
||||
for (const status of ALL_STATUSES) {
|
||||
expect(present.has(status), `état « ${status} » couvert`).toBe(true)
|
||||
}
|
||||
})
|
||||
|
||||
it('au moins une consignation route record, adoptée immédiatement, decidedHow posé', () => {
|
||||
const records = bundle.decisions.filter(d => d.route === 'record')
|
||||
expect(records.length).toBeGreaterThanOrEqual(1)
|
||||
for (const r of records) {
|
||||
expect(r.status).toBe('adopted')
|
||||
expect(r.decidedHow?.length).toBeGreaterThan(0)
|
||||
}
|
||||
expect(decision('marché du samedi').decidedHow).toContain('comme d’habitude')
|
||||
})
|
||||
})
|
||||
|
||||
describe('sessions — corpus, fenêtres, cohérence des états', () => {
|
||||
it('une session open et une session frozen existent', () => {
|
||||
expect(bundle.sessions.filter(s => s.status === 'open').length).toBeGreaterThanOrEqual(1)
|
||||
expect(bundle.sessions.filter(s => s.status === 'frozen')).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('chaque session : W = |corpus|, corpus ⊆ personnes, concerné·es beforeSnapshot', () => {
|
||||
for (const s of bundle.sessions) {
|
||||
expect(s.corpusSize).toBe(s.corpusPersonIds.length)
|
||||
expect(s.corpusSize).toBeGreaterThan(0)
|
||||
expect(protocolById.has(s.protocolId)).toBe(true)
|
||||
expect(decisionById.has(s.decisionId)).toBe(true)
|
||||
expect(s.opensAt < s.closesAt).toBe(true)
|
||||
for (const pid of s.corpusPersonIds) {
|
||||
expect(personIds.has(pid)).toBe(true)
|
||||
const concern = bundle.concerns.find(
|
||||
c => c.decisionId === s.decisionId && c.personId === pid && c.beforeSnapshot,
|
||||
)
|
||||
expect(concern, `concern beforeSnapshot pour ${pid}`).toBeDefined()
|
||||
expect(concern!.reason.length).toBeGreaterThan(0)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
it('chaque vote appartient au corpus arrêté de sa session', () => {
|
||||
for (const v of bundle.votes) {
|
||||
const s = bundle.sessions.find(sess => sess.id === v.sessionId)
|
||||
expect(s, 'session du vote').toBeDefined()
|
||||
expect(s!.corpusPersonIds).toContain(v.voterId)
|
||||
}
|
||||
})
|
||||
|
||||
it('statut des décisions cohérent avec leurs sessions', () => {
|
||||
for (const s of bundle.sessions) {
|
||||
const d = decisionById.get(s.decisionId)!
|
||||
if (s.status === 'open') {
|
||||
expect(s.closesAt > REF, `session ouverte non échue (« ${d.title} »)`).toBe(true)
|
||||
expect(d.status).toBe('voting')
|
||||
}
|
||||
if (s.status === 'frozen') {
|
||||
expect(s.closesAt < REF).toBe(true)
|
||||
expect(d.status).toBe('voting')
|
||||
}
|
||||
if (s.status === 'closed') {
|
||||
expect(s.outcome).toBeDefined()
|
||||
expect(['adopted', 'rejected', 'closed', 'revoked']).toContain(d.status)
|
||||
}
|
||||
}
|
||||
for (const d of bundle.decisions.filter(dd => dd.status === 'voting')) {
|
||||
const alive = sessionsOf(d.id).filter(s => s.status === 'open' || s.status === 'frozen')
|
||||
expect(alive, `« ${d.title} » en voting a sa session vivante`).toHaveLength(1)
|
||||
}
|
||||
})
|
||||
|
||||
it('votes : exactement un de value/values/choicePersonId — sauf blanc d’élection', () => {
|
||||
for (const v of bundle.votes) {
|
||||
const method = protocolById.get(bundle.sessions.find(s => s.id === v.sessionId)!.protocolId)!.method
|
||||
const set = [v.value !== undefined, v.values !== undefined, v.choicePersonId !== undefined]
|
||||
.filter(Boolean).length
|
||||
if (set === 0) {
|
||||
expect(method, 'seul un blanc d’élection peut ne rien porter').toBe('election')
|
||||
}
|
||||
else {
|
||||
expect(set).toBe(1)
|
||||
}
|
||||
if (v.value === 0 || v.value === 1 || v.value === 'against') {
|
||||
expect(v.comment, 'commentaire obligatoire sur vote négatif').toBeDefined()
|
||||
expect(v.comment!.length).toBeGreaterThan(0)
|
||||
}
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('le paramétrique d’exemple — « Répartir le budget d’ateliers 2026 »', () => {
|
||||
const d = decision('Répartir le budget d’ateliers 2026')
|
||||
const spec = d.paramSpec as ParamSpec
|
||||
const session = sessionsOf(d.id)[0]
|
||||
const votes = votesOf(session.id)
|
||||
|
||||
it('spec sum100 : 3 parts votées nommées + EXACTEMENT 1 part dérivée « Réserve » [0,30]', () => {
|
||||
expect(spec.constraint).toBe('sum100')
|
||||
expect(() => validateParamSpec(spec)).not.toThrow()
|
||||
const derived = spec.params.filter(p => p.derived === true)
|
||||
expect(derived).toHaveLength(1)
|
||||
expect(derived[0].label).toBe('Réserve')
|
||||
expect(derived[0].min).toBe(0)
|
||||
expect(derived[0].max).toBe(30)
|
||||
const voted = spec.params.filter(p => !p.derived)
|
||||
expect(voted).toHaveLength(3)
|
||||
expect(voted.every(p => p.kind === 'share')).toBe(true)
|
||||
expect(spec.impactAttrKey).toBe('heures/mois')
|
||||
})
|
||||
|
||||
it('la décision connexe de ressources et la session ouverte sont posées', () => {
|
||||
expect(d.resources).toEqual({ note: 'budget annuel ateliers', amount: 1200, unit: '€' })
|
||||
expect(session.status).toBe('open')
|
||||
expect(session.closesAt > REF).toBe(true)
|
||||
expect(d.status).toBe('voting')
|
||||
})
|
||||
|
||||
it('5-6 votes VALIDES de 3 valeurs — la réserve dérivée reste dans [0,30] pour CHAQUE vote', () => {
|
||||
expect(votes.length).toBeGreaterThanOrEqual(5)
|
||||
expect(votes.length).toBeLessThanOrEqual(6)
|
||||
for (const v of votes) {
|
||||
expect(v.values).toHaveLength(3)
|
||||
expect(() => validateVote(spec, v.values!)).not.toThrow()
|
||||
const full = resolveDerived(spec, v.values!)
|
||||
const reserve = full[spec.params.findIndex(p => p.derived === true)]
|
||||
expect(reserve).toBeGreaterThanOrEqual(0)
|
||||
expect(reserve).toBeLessThanOrEqual(30)
|
||||
expect(full.reduce((a, b) => a + b, 0)).toBeCloseTo(100)
|
||||
}
|
||||
})
|
||||
|
||||
it('faisceau, médiane basse et cristallisation sont calculables', () => {
|
||||
const values = votes.map(v => v.values!)
|
||||
const median = medianByElement(values)
|
||||
expect(median).toHaveLength(3)
|
||||
// Médiane basse = une position réellement votée, curseur par curseur.
|
||||
median.forEach((m, j) => {
|
||||
expect(values.some(v => v[j] === m)).toBe(true)
|
||||
})
|
||||
const crystal = crystallize(spec, values)
|
||||
expect(crystal).toHaveLength(4)
|
||||
expect(crystal.reduce((a, b) => a + b, 0)).toBeCloseTo(100)
|
||||
const reserve = crystal[spec.params.findIndex(p => p.derived === true)]
|
||||
expect(reserve).toBeGreaterThanOrEqual(0)
|
||||
expect(reserve).toBeLessThanOrEqual(30)
|
||||
// « Pour moi » : l'attribut déclaré existe chez au moins un membre du corpus.
|
||||
const corpusAttrs = session.corpusPersonIds
|
||||
.map(pid => bundle.people.find(p => p.id === pid)?.attributes?.['heures/mois'])
|
||||
.filter((h): h is number => typeof h === 'number')
|
||||
expect(corpusAttrs.length).toBeGreaterThan(0)
|
||||
})
|
||||
})
|
||||
|
||||
describe('la session figée — la carte « À cristalliser » du Fil', () => {
|
||||
const frozen = bundle.sessions.find(s => s.status === 'frozen')!
|
||||
const d = decisionById.get(frozen.decisionId)!
|
||||
|
||||
it('closesAt passé, votes figés valides, PAS de crystallizedById, garant posé', () => {
|
||||
expect(frozen.closesAt < REF).toBe(true)
|
||||
expect(frozen.crystallizedById).toBeUndefined()
|
||||
expect(frozen.crystallizedAt).toBeUndefined()
|
||||
expect(d.stewardIds.length).toBeGreaterThanOrEqual(1)
|
||||
expect(protocolById.get(frozen.protocolId)!.method).toBe('parametric')
|
||||
const votes = votesOf(frozen.id)
|
||||
expect(votes.length).toBeGreaterThanOrEqual(3)
|
||||
const spec = d.paramSpec as ParamSpec
|
||||
for (const v of votes) {
|
||||
expect(() => validateVote(spec, v.values!)).not.toThrow()
|
||||
}
|
||||
expect(medianByElement(votes.map(v => v.values!))).toHaveLength(spec.params.length)
|
||||
})
|
||||
})
|
||||
|
||||
describe('fenêtres d’objection — accord explicite et frontière', () => {
|
||||
it('l’accord explicite : décision non-easy en fenêtre avec ≥1 Assent d’un concerné ≠ auteur', () => {
|
||||
const d = decision('lave-linge')
|
||||
expect(d.status).toBe('objection')
|
||||
expect(d.reversibility).not.toBe('easy')
|
||||
expect(d.windowEndsAt! > REF).toBe(true)
|
||||
const assents = bundle.assents.filter(a => a.decisionId === d.id && a.personId !== d.authorId)
|
||||
expect(assents.length).toBeGreaterThanOrEqual(1)
|
||||
const concerned = bundle.concerns.some(
|
||||
c => c.decisionId === d.id && c.personId === assents[0].personId,
|
||||
)
|
||||
expect(concerned).toBe(true)
|
||||
expect(bundle.assents.length).toBeGreaterThanOrEqual(1)
|
||||
})
|
||||
|
||||
it('la frontière suspend : windowSuspendedAt posé + objection boundary ouverte', () => {
|
||||
const d = decision('serrure connectée')
|
||||
expect(d.status).toBe('objection')
|
||||
expect(d.windowSuspendedAt).toBeDefined()
|
||||
const boundary = bundle.objections.find(
|
||||
o => o.decisionId === d.id && o.kind === 'boundary' && o.status === 'open',
|
||||
)
|
||||
expect(boundary).toBeDefined()
|
||||
expect(boundary!.argument.length).toBeGreaterThan(0)
|
||||
})
|
||||
|
||||
it('la fenêtre d’avis est ouverte avec 2 avis déposés', () => {
|
||||
const d = decision('façade')
|
||||
expect(d.status).toBe('advice')
|
||||
expect(d.windowEndsAt! > REF).toBe(true)
|
||||
const advices = bundle.advices.filter(a => a.decisionId === d.id)
|
||||
expect(advices).toHaveLength(2)
|
||||
expect(new Set(advices.map(a => a.position)).size).toBeGreaterThan(1)
|
||||
})
|
||||
})
|
||||
|
||||
describe('formulation — 2 contre-propositions avec diff sur le Règlement', () => {
|
||||
const d = decision('Réviser l’accueil')
|
||||
|
||||
it('framing, amendsClauseId sur une clause du Règlement intérieur, 2 versions proposées distinctes', () => {
|
||||
expect(d.status).toBe('framing')
|
||||
const clause = clauseById.get(d.amendsClauseId!)!
|
||||
const ri = bundle.docs.find(doc => doc.role === 'reference')!
|
||||
expect(clause.docId).toBe(ri.id)
|
||||
const proposed = bundle.versions.filter(v => v.decisionId === d.id && v.status === 'proposed')
|
||||
expect(proposed).toHaveLength(2)
|
||||
expect(proposed[0].clauseId).toBe(clause.id)
|
||||
expect(proposed[1].clauseId).toBe(clause.id)
|
||||
expect(proposed[0].content).not.toBe(proposed[1].content)
|
||||
const current = bundle.versions.find(v => v.id === clause.currentVersionId)!
|
||||
expect(proposed.every(p => p.content !== current.content)).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('le Pacte résolu — des seuils DIFFÉRENTS des défauts', () => {
|
||||
const settings = resolveSettings(bundle.clauses, bundle.versions)
|
||||
|
||||
it('seuils propres : smallGroupMax 4, fenêtres 24/48, requireEffects binding', () => {
|
||||
expect(settings.triage.smallGroupMax).toBe(4)
|
||||
expect(settings.triage.objectionWindowHours).toBe(24)
|
||||
expect(settings.triage.adviceWindowHours).toBe(48)
|
||||
expect(settings.triage.requireEffects).toBe('binding')
|
||||
// Les autres clés restent aux défauts, mais VOTÉES (clauses présentes).
|
||||
expect(settings.triage.collectiveMin).toBe(50)
|
||||
expect(settings.triage.consentMax).toBe(7)
|
||||
expect(settings.triage.framingDays).toBe(14)
|
||||
expect(settings.triage.reviewDelayDays).toBe(90)
|
||||
})
|
||||
|
||||
it('protocolByRange.large → le protocole NUANCÉ (la démonstration anti-binaire)', () => {
|
||||
const large = protocolById.get(settings.protocolByRange.large!)
|
||||
expect(large?.method).toBe('nuanced')
|
||||
expect(bundle.protocols.some(p => p.method === 'binary')).toBe(false)
|
||||
})
|
||||
|
||||
it('le protocole Consentement OBLIGATOIRE est résolu, tous les autres aussi', () => {
|
||||
const consent = protocolById.get(settings.protocolByRange.consent)
|
||||
expect(consent?.method).toBe('consent')
|
||||
expect(consent?.durationDays).toBe(7)
|
||||
expect(protocolById.get(settings.protocolByRange.nuanced!)?.method).toBe('nuanced')
|
||||
expect(protocolById.get(settings.protocolByRange.parametric!)?.method).toBe('parametric')
|
||||
expect(protocolById.get(settings.protocolByRange.election!)?.method).toBe('election')
|
||||
})
|
||||
|
||||
it('les protocoles portent les seuils demandés, tous ballot open', () => {
|
||||
const nuanced = bundle.protocols.find(p => p.method === 'nuanced')!
|
||||
expect(nuanced.formula.nuancedMinParticipants).toBe(4)
|
||||
expect(nuanced.formula.nuancedThresholdPct).toBe(60)
|
||||
const parametric = bundle.protocols.find(p => p.method === 'parametric')!
|
||||
expect(parametric.formula.parametricMinParticipants).toBe(4)
|
||||
const election = bundle.protocols.find(p => p.method === 'election')!
|
||||
expect(election.formula.electionMinParticipants).toBe(5)
|
||||
expect(election.formula.tieBreak).toBe('runoff')
|
||||
expect(bundle.protocols.every(p => p.ballot === 'open')).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('les textes — toute clause naît d’une décision', () => {
|
||||
it('chaque clause courante a sa version current ET sa décision fondatrice adoptée', () => {
|
||||
for (const clause of bundle.clauses) {
|
||||
const current = bundle.versions.find(
|
||||
v => v.id === clause.currentVersionId && v.clauseId === clause.id && v.status === 'current',
|
||||
)
|
||||
expect(current, `version courante de ${clause.code}`).toBeDefined()
|
||||
const founding = decisionById.get(current!.decisionId)
|
||||
expect(founding, `décision fondatrice de ${clause.code}`).toBeDefined()
|
||||
expect(['adopted', 'closed']).toContain(founding!.status)
|
||||
expect(current!.adoptedAt).toBeDefined()
|
||||
}
|
||||
})
|
||||
|
||||
it('le Règlement intérieur : 8 clauses réparties sur les 4 presets d’inertie', () => {
|
||||
const ri = bundle.docs.find(doc => doc.role === 'reference')!
|
||||
const riClauses = bundle.clauses.filter(c => c.docId === ri.id)
|
||||
expect(riClauses).toHaveLength(8)
|
||||
const presets = new Set(riClauses.map(c => c.inertia))
|
||||
expect(presets).toEqual(new Set(['low', 'standard', 'high', 'max']))
|
||||
})
|
||||
|
||||
it('le Pacte : A1, préambule, et les 10 clés de triage en settingKey', () => {
|
||||
const pactClauses = bundle.clauses.filter(c => c.docId === bundle.collective.pactDocId)
|
||||
expect(pactClauses.some(c => c.code === 'A1' && c.title === 'Notre finalité')).toBe(true)
|
||||
expect(pactClauses.some(c => c.section === 'Préambule')).toBe(true)
|
||||
const keys = new Set(pactClauses.map(c => c.settingKey).filter(Boolean))
|
||||
for (const k of [
|
||||
'triage.smallGroupMax', 'triage.collectiveMin', 'triage.consentMax',
|
||||
'triage.objectionWindowHours', 'triage.adviceWindowHours', 'triage.framingDays',
|
||||
'triage.concernEscalateRatio', 'triage.recurrenceThreshold', 'triage.reviewDelayDays',
|
||||
'triage.requireEffects',
|
||||
]) {
|
||||
expect(keys.has(k), `clé ${k} votée au Pacte`).toBe(true)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('le mandat Trésorerie — les feux de la rampe', () => {
|
||||
const mandate = bundle.mandates.find(m => m.title === 'Trésorerie')!
|
||||
|
||||
it('actif, titulaire au Bureau, cercle électeur = racine, né d’une décision adoptée', () => {
|
||||
expect(mandate.status).toBe('active')
|
||||
const bureau = bundle.circles.find(c => c.kind === 'team')!
|
||||
expect(bureau.memberIds).toContain(mandate.holderId)
|
||||
expect(mandate.electorCircleId).toBe(bundle.collective.rootCircleId)
|
||||
const origin = decisionById.get(mandate.originDecisionId)!
|
||||
expect(origin.status).toBe('adopted')
|
||||
expect(origin.createsMandate?.title).toBe('Trésorerie')
|
||||
expect(mandate.nominationMethod).toBe('election-no-candidate')
|
||||
})
|
||||
|
||||
it('1 rapport rendu + 1 rapport dû non rendu', () => {
|
||||
const delivered = mandate.reports.filter(r => r.deliveredAt)
|
||||
const due = mandate.reports.filter(r => !r.deliveredAt && r.dueAt < REF)
|
||||
expect(delivered).toHaveLength(1)
|
||||
expect(delivered[0].content!.length).toBeGreaterThan(0)
|
||||
expect(due).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('2 décisions prises sous mandat : une adoptée à fenêtre passée, une en fenêtre', () => {
|
||||
const under = bundle.decisions.filter(d => d.underMandateId === mandate.id)
|
||||
expect(under).toHaveLength(2)
|
||||
const adopted = under.find(d => d.status === 'adopted')!
|
||||
expect(adopted.windowEndsAt! < REF).toBe(true)
|
||||
expect(adopted.decidedAt).toBeDefined()
|
||||
const inWindow = under.find(d => d.status === 'objection')!
|
||||
expect(inWindow.windowEndsAt! > REF).toBe(true)
|
||||
expect(under.every(d => d.route === 'mandate')).toBe(true)
|
||||
})
|
||||
|
||||
it('la décision créatrice a été élue sans candidat, blanc compris', () => {
|
||||
const origin = decisionById.get(mandate.originDecisionId)!
|
||||
const session = sessionsOf(origin.id)[0]
|
||||
expect(session.status).toBe('closed')
|
||||
expect(session.outcome).toBe('adopted')
|
||||
const votes = votesOf(session.id)
|
||||
expect(votes.length).toBeGreaterThanOrEqual(5) // quorum electionMinParticipants
|
||||
const blank = votes.filter(v => !v.value && !v.values && !v.choicePersonId)
|
||||
expect(blank).toHaveLength(1)
|
||||
const designations = votes.filter(v => v.choicePersonId === mandate.holderId)
|
||||
expect(designations.length).toBeGreaterThan(votes.length / 2)
|
||||
})
|
||||
})
|
||||
|
||||
describe('le dossier découpé — décision incrémentielle', () => {
|
||||
const parent = decision('Réaménager le local du quai')
|
||||
const elements = bundle.decisions.filter(
|
||||
d => d.parentDecisionId === parent.id && d.chainKind === 'element',
|
||||
)
|
||||
|
||||
it('parent structural en framing, 2 éléments : 1 adopté (terminal), 1 en voting', () => {
|
||||
expect(parent.status).toBe('framing')
|
||||
expect(parent.weight).toBe('structural')
|
||||
expect(parent.stewardIds.length).toBeGreaterThanOrEqual(1) // le garant qui clora
|
||||
expect(elements).toHaveLength(2)
|
||||
expect(elements.filter(e => e.status === 'adopted')).toHaveLength(1)
|
||||
expect(elements.filter(e => e.status === 'voting')).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('les enjeux sont pondérés : Concern.priority 0-3 posés par 3-4 personnes et par élément', () => {
|
||||
for (const element of elements) {
|
||||
const weighted = bundle.concerns.filter(
|
||||
c => c.decisionId === element.id && c.priority !== undefined,
|
||||
)
|
||||
expect(weighted.length).toBeGreaterThanOrEqual(3)
|
||||
expect(weighted.length).toBeLessThanOrEqual(4)
|
||||
for (const c of weighted) {
|
||||
expect([0, 1, 2, 3]).toContain(c.priority)
|
||||
}
|
||||
}
|
||||
// La palette 0-3 est réellement utilisée à travers le dossier.
|
||||
const used = new Set(
|
||||
bundle.concerns
|
||||
.filter(c => elements.some(e => e.id === c.decisionId) && c.priority !== undefined)
|
||||
.map(c => c.priority),
|
||||
)
|
||||
expect(used).toEqual(new Set([0, 1, 2, 3]))
|
||||
})
|
||||
})
|
||||
|
||||
describe('la boucle apprenante', () => {
|
||||
it('l’épreuve du réel DUE : review échue sans verdict, matière ciblée, ressources, paire garant/mesureur', () => {
|
||||
const d = decision('poêle à granulés')
|
||||
expect(d.status).toBe('adopted')
|
||||
expect(d.review?.dueAt).toBeDefined()
|
||||
expect(d.review!.dueAt < REF).toBe(true)
|
||||
expect(d.review!.verdict).toBeUndefined()
|
||||
expect(d.brief!.effects.length).toBeGreaterThanOrEqual(1)
|
||||
expect(d.brief!.effects.some(e => e.target)).toBe(true) // structural ⇒ cible mesurable
|
||||
expect(d.resources).toMatchObject({ amount: 2400, unit: '€' })
|
||||
expect(d.stewardIds.length).toBeGreaterThanOrEqual(1)
|
||||
expect(d.measurerIds.length).toBeGreaterThanOrEqual(1)
|
||||
})
|
||||
|
||||
it('révoquée avec sa chaîne : enfant revocation adoptée — « ce qu’on en a appris »', () => {
|
||||
const revoked = bundle.decisions.find(d => d.status === 'revoked')!
|
||||
const child = bundle.decisions.find(
|
||||
d => d.parentDecisionId === revoked.id && d.chainKind === 'revocation',
|
||||
)!
|
||||
expect(child.status).toBe('adopted')
|
||||
expect(revoked.review?.verdict).toBe('revoke')
|
||||
})
|
||||
|
||||
it('conservatoire ratifiée : urgent:true adoptée + enfant ratification adopté', () => {
|
||||
const urgent = bundle.decisions.find(d => d.urgent && d.status === 'adopted')!
|
||||
const ratification = bundle.decisions.find(
|
||||
d => d.parentDecisionId === urgent.id && d.chainKind === 'ratification',
|
||||
)!
|
||||
expect(ratification.status).toBe('adopted')
|
||||
expect(urgent.reversibility).not.toBe('irreversible') // l’urgence ne contourne pas l’irréversible
|
||||
})
|
||||
|
||||
it('une décision close par l’épreuve du réel confirmée', () => {
|
||||
const closed = bundle.decisions.find(d => d.status === 'closed')!
|
||||
expect(closed.review?.verdict).toBe('confirmed')
|
||||
expect(closed.brief?.effects.some(e => e.measured)).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('le vote nuancé en cours — l’histogramme vivant', () => {
|
||||
it('5 votes 0-5, commentaires obligatoires posés sur les 0-1', () => {
|
||||
const d = decision('réseau des ateliers partagés')
|
||||
const session = sessionsOf(d.id).find(s => s.status === 'open')!
|
||||
const votes = votesOf(session.id)
|
||||
expect(votes).toHaveLength(5)
|
||||
for (const v of votes) {
|
||||
expect([0, 1, 2, 3, 4, 5]).toContain(v.value)
|
||||
if (v.value === 0 || v.value === 1) expect(v.comment!.length).toBeGreaterThan(0)
|
||||
}
|
||||
// Distribution nuancée réelle : au moins 4 niveaux distincts.
|
||||
expect(new Set(votes.map(v => v.value)).size).toBeGreaterThanOrEqual(4)
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user