ajoute un utilitaire pour tester un arbre

Author: vmaubert

packages/api/src/business/rules-demarches/machine-helper.ts

@@ -2,7 +2,7 @@ import { AnyMachineSnapshot, createActor, EventObject, MachineSnapshot, StateMac
 import { CaminoCommonContext, DBEtat, Etape, Intervenant, intervenants, tags } from './machine-common'
 import { DemarchesStatutsIds, DemarcheStatutId } from 'camino-common/src/static/demarchesStatuts'
 import { CaminoDate } from 'camino-common/src/date'
-import { OmitDistributive } from 'camino-common/src/typescript-tools'
+import { isNotNullNorUndefined, OmitDistributive } from 'camino-common/src/typescript-tools'
 
 type CaminoState<CaminoContext extends CaminoCommonContext, CaminoEvent extends EventObject> = MachineSnapshot<CaminoContext, CaminoEvent, any, any, any, any, any>
 
@@ -214,28 +214,31 @@ export abstract class CaminoMachine<CaminoContext extends CaminoCommonContext, C
     return intervenants.filter(r => responsables.includes(tags.responsable[r]))
   }
 
+  public possibleNextEvents(state: CaminoState<CaminoContext, CaminoEvent>, date: CaminoDate): CaminoEvent[] {
+    return getNextEvents(state)
+      .filter((event: string) => this.isEvent(event))
+      .flatMap(event => {
+        const events = this.toPotentialCaminoXStateEvent(event, date)
+
+        return events.filter(event => {
+          return state.can(event) && state.status !== 'done'
+        })
+      })
+      .filter(isNotNullNorUndefined)
+      .toSorted((a, b) => a.type.localeCompare(b.type))
+  }
+
   public possibleNextEtapes(etapes: readonly Etape[], date: CaminoDate): (OmitDistributive<Etape, 'date' | 'titreTypeId' | 'demarcheTypeId'> & { mainStep: boolean })[] {
     const state = this.assertGoTo(etapes)
 
-    if (state !== undefined) {
-      return getNextEvents(state)
-        .filter((event: string) => this.isEvent(event))
-        .flatMap(event => {
-          const events = this.toPotentialCaminoXStateEvent(event, date)
-
-          return events
-            .filter(event => {
-              return state.can(event) && state.status !== 'done'
-            })
-            .flatMap(event => this.caminoXStateEventToEtapes(event))
-        })
-        .filter(event => event !== undefined)
+    if (isNotNullNorUndefined(state)) {
+      return this.possibleNextEvents(state, date).flatMap(this.caminoXStateEventToEtapes).filter(isNotNullNorUndefined)
     }
 
     return []
   }
 }
 
-export function getNextEvents(snapshot: AnyMachineSnapshot): string[] {
+function getNextEvents(snapshot: AnyMachineSnapshot): string[] {
   return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])]
 }

packages/api/src/business/rules-demarches/machine-test-helper.ts

@@ -1,10 +1,11 @@
 import { CaminoCommonContext, Etape } from './machine-common'
 import { Actor, EventObject, createActor } from 'xstate'
-import { CaminoMachine, getNextEvents } from './machine-helper'
+import { CaminoMachine } from './machine-helper'
 import { expect } from 'vitest'
 import { CaminoDate, dateAddDays, toCaminoDate } from 'camino-common/src/date'
 import { EtapeTypeEtapeStatutValidPair } from 'camino-common/src/static/etapesTypesEtapesStatuts'
-import { isNotNullNorUndefined } from 'camino-common/src/typescript-tools'
+import { isNotNullNorUndefined, onlyUnique } from 'camino-common/src/typescript-tools'
+import { DemarchesStatuts } from 'camino-common/src/static/demarchesStatuts'
 interface CustomMatchers<R = unknown> {
   canOnlyTransitionTo<T extends EventObject, C extends CaminoCommonContext>(context: { machine: CaminoMachine<C, T>; date: CaminoDate }, _events: T['type'][]): R
 }
@@ -19,21 +20,18 @@ declare global {
     interface InverseAsymmetricMatchers extends CustomMatchers {}
   }
 }
+
 expect.extend({
   canOnlyTransitionTo<T extends EventObject, C extends CaminoCommonContext>(
     service: Actor<CaminoMachine<C, T>['machine']>,
     { machine, date }: { machine: CaminoMachine<C, T>; date: CaminoDate },
     events: T['type'][]
   ) {
     events = events.toSorted()
-    const passEvents: (typeof events)[number][] = getNextEvents(service.getSnapshot())
-      .filter((event: string) => machine.isEvent(event))
-      .filter((event: (typeof events)[number]) => {
-        const events = machine.toPotentialCaminoXStateEvent(event, date)
-
-        return events.some(event => service.getSnapshot().can(event) && service.getSnapshot().status !== 'done')
-      })
-      .toSorted()
+    const passEvents = machine
+      .possibleNextEvents(service.getSnapshot(), date)
+      .map(({ type }) => type)
+      .filter(onlyUnique)
 
     if (passEvents.length !== events.length || passEvents.some((entry, index) => entry !== events[index])) {
       return {
@@ -62,14 +60,10 @@ export const interpretMachine = <T extends EventObject, C extends CaminoCommonCo
       throw new Error(
         `Error: cannot execute step: '${JSON.stringify(etapeAFaire)}' after '${JSON.stringify(
           etapes.slice(0, i).map(etape => etape.etapeTypeId + '_' + etape.etapeStatutId)
-        )}'. The event ${JSON.stringify(event)} should be one of '${getNextEvents(service.getSnapshot())
-          .filter(event => machine.isEvent(event))
-          .filter((event: EventObject['type']) => {
-            const events = machine.toPotentialCaminoXStateEvent(event, etapeAFaire.date)
-
-            return events.some(event => service.getSnapshot().can(event) && service.getSnapshot().status !== 'done')
-          })
-          .toSorted()}'`
+        )}'. The event ${JSON.stringify(event)} should be one of '${machine
+          .possibleNextEvents(service.getSnapshot(), etapeAFaire.date)
+          .map(({ type }) => type)
+          .filter(onlyUnique)}'`
       )
     }
     service.send(event)
@@ -78,6 +72,50 @@ export const interpretMachine = <T extends EventObject, C extends CaminoCommonCo
   return service
 }
 
+export const getEventsTree = <T extends EventObject, C extends CaminoCommonContext>(
+  machine: CaminoMachine<C, T>,
+  initDate: `${number}-${number}-${number}`,
+  etapes: readonly (EtapeTypeEtapeStatutValidPair & Omit<Etape, 'date' | 'etapeTypeId' | 'etapeStatutId' | 'titreTypeId' | 'demarcheTypeId'> & { addDays?: number })[]
+): string[] => {
+  const { service, dateFin } = setDateAndOrderAndInterpretMachine(machine, initDate, [])
+  const passEvents: T['type'][] = machine
+    .possibleNextEvents(service.getSnapshot(), dateFin)
+    .map(({ type }) => type)
+    .filter(onlyUnique)
+
+  const steps = [
+    {
+      type: 'RIEN',
+      visibilite: service.getSnapshot().context.visibilite,
+      demarcheStatut: DemarchesStatuts[service.getSnapshot().context.demarcheStatut].nom,
+      events: passEvents,
+    },
+    ...etapes.map((_etape, index) => {
+      const etapesToLaunch = etapes.slice(0, index + 1)
+      const { service, dateFin, etapes: etapesWithDates } = setDateAndOrderAndInterpretMachine(machine, initDate, etapesToLaunch)
+
+      const passEvents: T['type'][] = machine
+        .possibleNextEvents(service.getSnapshot(), dateFin)
+        .map(({ type }) => type)
+        .filter(onlyUnique)
+      const event = machine.eventFrom(etapesWithDates[etapesWithDates.length - 1])
+
+      return {
+        type: event.type,
+        visibilite: service.getSnapshot().context.visibilite,
+        demarcheStatut: DemarchesStatuts[service.getSnapshot().context.demarcheStatut].nom,
+        events: passEvents,
+      }
+    }),
+  ]
+
+  const maxPadType = Math.max(...steps.map(({ type }) => type.length))
+
+  return steps.map(step => {
+    return `${step.type.padEnd(maxPadType, ' ')} (${step.visibilite.padEnd(14, ' ')}, ${step.demarcheStatut.padEnd(23, ' ')}) -> [${step.events.join(',')}]`
+  })
+}
+
 export const setDateAndOrderAndInterpretMachine = <T extends EventObject, C extends CaminoCommonContext>(
   machine: CaminoMachine<C, T>,
   initDate: `${number}-${number}-${number}`,