change API behavior : return onlyEligible by default. Return also not…

… eligible if specifically asked. Fixing the testing,
betagouv · Oct 16, 2024 · cecf0b9 · cecf0b9
1 parent 16ae026
commit cecf0b9
Show file tree

Hide file tree

Showing 3 changed files with 27 additions and 10 deletions.
diff --git a/libs/backend-ddd/src/program/domain/filterPrograms.ts b/libs/backend-ddd/src/program/domain/filterPrograms.ts
@@ -35,7 +35,7 @@ export const filterPrograms = (
     // since publicodes return a single boolean or undefined value and we want to know if ineligible programs
     // are ineligible because of the inputData of because of their EOL, we need an other publicodes evaluation for this specific question
     let dateEvaluation: Result<boolean | undefined, Error> = Result.ok(true)
-    if (inputData.onlyEligible === false) {
+    if (inputData.onlyEligible !== true) {
       dateEvaluation = rulesService.evaluate(FILTERING_RULE_NAME, program, {}, currentDate)
     }
     if (dateEvaluation.isErr) {
@@ -63,7 +63,7 @@ const shouldKeepProgram = (programEligibility: ProgramEligibilityType, onlyEligi
     return false
   }
 
-  if (!onlyEligible || typeof onlyEligible === 'undefined') {
+  if (onlyEligible === false) {
     return true
   }
 

diff --git a/libs/backend-ddd/tests/program/filterPrograms.test.ts b/libs/backend-ddd/tests/program/filterPrograms.test.ts
@@ -1,13 +1,13 @@
 import { type Rules, makeProgramHelper, mockCurrentDateService, makeProgramsRepository } from './testing'
 import { FILTERING_RULE_NAME } from '../../src/program/domain/filterPrograms'
-import type { ProgramType } from '@tee/data'
+import { ProgramEligibilityType, ProgramTypeWithEligibility, type ProgramType } from '@tee/data'
 import { expectToBeOk } from '../testing'
 import ProgramFeatures from '../../src/program/domain/programFeatures'
 import { type Result } from 'true-myth'
 import { PublicodesService } from '../../src/program/infrastructure/publicodesService'
 import { QuestionnaireRoute, QuestionnaireData } from '@tee/common'
 
-const defaultFilterPrograms = (programs: ProgramType[], inputData: Record<string, number>): Result<ProgramType[], Error> => {
+const defaultFilterPrograms = (programs: ProgramType[], inputData: Record<string, number>): Result<ProgramTypeWithEligibility[], Error> => {
   PublicodesService.init(programs)
   const programService = new ProgramFeatures(makeProgramsRepository(programs), mockCurrentDateService, PublicodesService.getInstance())
   const questionnaireData: QuestionnaireData = {
@@ -20,6 +20,13 @@ const defaultFilterPrograms = (programs: ProgramType[], inputData: Record<string
   return programService.getFilteredBy(questionnaireData)
 }
 
+const addEligibility = (programs: ProgramType[]): ProgramTypeWithEligibility[] => {
+  return programs.map((program) => ({
+    ...program,
+    eligibility: ProgramEligibilityType.Eligible
+  }))
+}
+
 const rulesBoilerplate = {
   entreprise: null,
   'entreprise . effectif': null,
@@ -124,13 +131,14 @@ EXPECT that the filtering only keeps programs that are eligible (rule
 
       const result = defaultFilterPrograms(programs, tc.inputData)
 
+      const programWithElibibility = addEligibility(programs)
       expectToBeOk(result)
 
       const filteredPrograms = result.value
       expect(filteredPrograms.length).toBe(tc.expectedProgramIndexes.length)
 
       tc.expectedProgramIndexes.forEach((expectedProgramIndex, index) => {
-        expect(filteredPrograms[index]).toBe(programs[expectedProgramIndex])
+        expect(filteredPrograms[index]).toStrictEqual(programWithElibibility[expectedProgramIndex])
       })
     })
   })

diff --git a/libs/backend-ddd/tests/program/sortPrograms.test.ts b/libs/backend-ddd/tests/program/sortPrograms.test.ts
@@ -1,14 +1,23 @@
 import { sortPrograms } from '../../src/program/domain/sortPrograms'
 import { QuestionnaireRoute } from '@tee/common'
-import { ProgramType, ProgramAidType } from '@tee/data'
+import { ProgramType, ProgramAidType, ProgramEligibilityType, ProgramTypeWithEligibility } from '@tee/data'
 import { makeProgramHelper } from './testing'
 
-const makeProgram = (id: string, nature: ProgramAidType, cost = '') =>
-  makeProgramHelper({
+const makeProgram = (id: string, nature: ProgramAidType, cost = '') => ({
+  ...makeProgramHelper({
     id: id,
     nature: nature,
     cost: cost
-  })
+  }),
+  eligibility: ProgramEligibilityType.Eligible
+})
+
+const addEligibility = (programs: ProgramType[]): ProgramTypeWithEligibility[] => {
+  return programs.map((program) => ({
+    ...program,
+    eligibility: ProgramEligibilityType.Eligible
+  }))
+}
 
 type TestCase = {
   name: string
@@ -153,7 +162,7 @@ EXPECT that the programs respect a set of given rules
 
   allTestCases.map((tc) => {
     test(`${tc.questionnaireRoute}: ${tc.name}`, () => {
-      const sortedPrograms = sortPrograms(tc.programs, tc.questionnaireRoute!)
+      const sortedPrograms = sortPrograms(addEligibility(tc.programs), tc.questionnaireRoute)
       expect(sortedPrograms).toHaveLength(tc.expectedIdOrder.length)
 
       const expectedSortedPrograms = tc.expectedIdOrder.map((id) => {