test: (next) api tests (#941)

next/package.json

@@ -46,6 +46,7 @@
     "eslint-plugin-react-refresh": "^0.4.16",
     "globals": "^15.14.0",
     "jsdom": "^26.0.0",
+    "nock": "^14.0.1",
     "postcss": "^8.5.1",
     "tailwindcss": "^4.0.0",
     "typescript": "~5.6.2",

next/src/api/questionnaires.test.ts

@@ -0,0 +1,68 @@
+import nock from 'nock';
+
+import { TargetModes } from '@/models/questionnaires';
+
+import {
+  type Questionnaire as PoguesQuestionnaire,
+  SurveyModeEnum,
+} from './models/pogues';
+import {
+  getQuestionnaire,
+  getQuestionnaires,
+  postQuestionnaire,
+  putQuestionnaire,
+} from './questionnaires';
+
+vi.mock('@/contexts/oidc');
+
+const poguesQuestionnaire = {
+  id: 'id',
+  Name: 'name',
+  Label: ['title'],
+  TargetMode: [SurveyModeEnum.CAPI],
+  DataCollection: [],
+  lastUpdatedDate:
+    'Tue Nov 19 2024 11:36:56 GMT+0100 (heure normale d’Europe centrale)',
+};
+
+const questionnaire = {
+  id: 'id',
+  title: 'title',
+  targetModes: new Set([TargetModes.CAPI]),
+  lastUpdatedDate: new Date('2024-11-19T10:36:56Z'),
+  codesLists: [],
+};
+
+it('Get questionnaires works', async () => {
+  const questionnaires: PoguesQuestionnaire[] = [poguesQuestionnaire];
+
+  nock('https://mock-api')
+    .get('/persistence/questionnaires/search/meta?owner=my-stamp')
+    .reply(200, questionnaires);
+
+  const res = await getQuestionnaires('my-stamp');
+  expect(res).toEqual([questionnaire]);
+});
+
+it('Get questionnaire works', async () => {
+  nock('https://mock-api')
+    .get('/persistence/questionnaire/id')
+    .reply(200, poguesQuestionnaire);
+
+  const res = await getQuestionnaire('id');
+  expect(res).toEqual(questionnaire);
+});
+
+it('Post questionnaire works', async () => {
+  nock('https://mock-api').post('/persistence/questionnaires').reply(201);
+
+  const res = await postQuestionnaire(questionnaire, 'my-stamp');
+  expect(res.status).toEqual(201);
+});
+
+it('Put questionnaire works', async () => {
+  nock('https://mock-api').put('/persistence/questionnaire/id').reply(200);
+
+  const res = await putQuestionnaire('id', poguesQuestionnaire);
+  expect(res.status).toEqual(200);
+});

next/src/api/questionnaires.ts

@@ -1,14 +1,14 @@
 import { queryOptions } from '@tanstack/react-query';
 
-import { CodesList } from '@/models/codesLists';
-import { Questionnaire } from '@/models/questionnaires';
+import type { CodesList } from '@/models/codesLists';
+import type { Questionnaire } from '@/models/questionnaires';
 
 import { instance } from './instance';
-import { Questionnaire as PoguesQuestionnaire } from './models/pogues';
+import type { Questionnaire as PoguesQuestionnaire } from './models/pogues';
 import { computePoguesCodesLists } from './utils/codesLists';
 import {
-  computePoguesQuestionnaire,
-  computeQuestionnaireFromPogues,
+  computeNewPoguesQuestionnaire,
+  computeQuestionnaire,
 } from './utils/questionnaires';
 
 /**
@@ -36,7 +36,9 @@ export const questionnaireQueryOptions = (questionnaireId: string) =>
 /**
  * Retrieve questionnaires associated to the provided stamp (e.g. "DR59-SNDI59").
  */
-async function getQuestionnaires(stamp: string): Promise<Questionnaire[]> {
+export async function getQuestionnaires(
+  stamp: string,
+): Promise<Questionnaire[]> {
   return instance
     .get('/persistence/questionnaires/search/meta', {
       params: { owner: stamp },
@@ -45,20 +47,20 @@ async function getQuestionnaires(stamp: string): Promise<Questionnaire[]> {
     .then(({ data }: { data: PoguesQuestionnaire[] }) => {
       const res: Questionnaire[] = [];
       for (const datum of data) {
-        res.push(computeQuestionnaireFromPogues(datum));
+        res.push(computeQuestionnaire(datum));
       }
       return res;
     });
 }
 
 /** Retrieve a questionnaire by id. */
-async function getQuestionnaire(id: string): Promise<Questionnaire> {
+export async function getQuestionnaire(id: string): Promise<Questionnaire> {
   return instance
     .get(`/persistence/questionnaire/${id}`, {
       headers: { Accept: 'application/json' },
     })
     .then(({ data }: { data: PoguesQuestionnaire }) => {
-      return computeQuestionnaireFromPogues(data);
+      return computeQuestionnaire(data);
     });
 }
 
@@ -69,7 +71,7 @@ export async function postQuestionnaire(
 ): Promise<Response> {
   return instance.post(
     '/persistence/questionnaires',
-    computePoguesQuestionnaire(qr, stamp),
+    computeNewPoguesQuestionnaire(qr, stamp),
     {
       headers: { 'Content-Type': 'application/json' },
     },

next/src/api/stamps.test.ts

@@ -0,0 +1,16 @@
+import nock from 'nock';
+
+import { getStamps } from './stamps';
+
+vi.mock('@/contexts/oidc');
+
+it('Get stamps', async () => {
+  const stamps = [{ label: 'my-stamp', value: 'stamp-1' }];
+
+  nock('https://mock-api')
+    .get('/persistence/questionnaires/stamps')
+    .reply(200, stamps);
+
+  const res = await getStamps();
+  expect(res).toEqual(stamps);
+});

next/src/api/stamps.ts

@@ -16,7 +16,7 @@ export const stampsQueryOptions = () =>
   });
 
 /** Retrieve stamps which allow to fetch questionnaires associated to one. */
-async function getStamps(): Promise<Stamp[]> {
+export async function getStamps(): Promise<Stamp[]> {
   return instance
     .get('/persistence/questionnaires/stamps', {
       headers: { Accept: 'application/json' },

next/src/api/utils/codesLists.test.ts

@@ -0,0 +1,45 @@
+import { CodesList } from '@/models/codesLists';
+
+import { CodeList as PoguesCodesList } from '../models/pogues';
+import { computeCodesLists, computePoguesCodesLists } from './codesLists';
+
+const codesLists: CodesList[] = [
+  {
+    id: 'id-1',
+    label: 'label-1',
+    codes: [
+      { label: 'code-1', value: 'code-value-1' },
+      { label: 'code-2', value: 'code-value-2' },
+    ],
+  },
+];
+
+const poguesCodesLists: PoguesCodesList[] = [
+  {
+    id: 'id-1',
+    Name: 'label-1',
+    Label: 'label-1',
+    Code: [
+      { Label: 'code-1', Value: 'code-value-1' },
+      { Label: 'code-2', Value: 'code-value-2' },
+    ],
+  },
+];
+
+describe('computeCodesLists', () => {
+  it('works', () => {
+    expect(computeCodesLists(poguesCodesLists)).toEqual(codesLists);
+  });
+  it('works with empty list', () => {
+    expect(computeCodesLists([])).toEqual([]);
+  });
+});
+
+describe('computePoguesCodesLists', () => {
+  it('works', () => {
+    expect(computePoguesCodesLists(codesLists)).toEqual(poguesCodesLists);
+  });
+  it('works with empty list', () => {
+    expect(computeCodesLists([])).toEqual([]);
+  });
+});

next/src/api/utils/codesLists.ts

@@ -1,12 +1,13 @@
 import { Code, CodesList } from '@/models/codesLists';
 
 import {
-  CodeType as PogueCode,
-  CodeList as PogueCodesList,
+  CodeType as PoguesCode,
+  CodeList as PoguesCodesList,
 } from '../models/pogues';
 
+/** Compute codes lists that can be used in our app from API data. */
 export function computeCodesLists(
-  codesLists: PogueCodesList[] = [],
+  codesLists: PoguesCodesList[] = [],
 ): CodesList[] {
   const res: CodesList[] = [];
   for (const codesList of codesLists) {
@@ -20,7 +21,7 @@ export function computeCodesLists(
   return res;
 }
 
-function computeCodes(codes: PogueCode[] = []): Code[] {
+function computeCodes(codes: PoguesCode[] = []): Code[] {
   const res: Code[] = [];
   for (const code of codes) {
     const datum = {
@@ -33,10 +34,11 @@ function computeCodes(codes: PogueCode[] = []): Code[] {
   return res;
 }
 
+/** Compute codes lists that can be sent to the API from our app data. */
 export function computePoguesCodesLists(
   codesLists: CodesList[] = [],
-): PogueCodesList[] {
-  const res: PogueCodesList[] = [];
+): PoguesCodesList[] {
+  const res: PoguesCodesList[] = [];
   for (const codesList of codesLists) {
     const datum = {
       id: codesList.id,
@@ -49,8 +51,8 @@ export function computePoguesCodesLists(
   return res;
 }
 
-function computePoguesCodes(codes: Code[] = []): PogueCode[] {
-  const res: PogueCode[] = [];
+function computePoguesCodes(codes: Code[] = []): PoguesCode[] {
+  const res: PoguesCode[] = [];
   for (const code of codes) {
     const datum = {
       Label: code.label,

next/src/api/utils/flowLogic.test.ts

@@ -0,0 +1,17 @@
+import { FlowLogics } from '@/models/questionnaires';
+
+import { FlowLogicEnum } from '../models/pogues';
+import { computePoguesFlowLogic } from './flowLogic';
+
+describe('computePoguesFlowLogic', () => {
+  it.each([
+    [FlowLogics.Filter, FlowLogicEnum.Filter],
+    [FlowLogics.Redirection, FlowLogicEnum.Redirection],
+  ])('%s -> %s', (input, expected) => {
+    expect(computePoguesFlowLogic(input)).toEqual(expected);
+  });
+
+  it('works with default', () => {
+    expect(computePoguesFlowLogic()).toEqual(FlowLogicEnum.Filter);
+  });
+});

next/src/api/utils/flowLogic.ts

@@ -0,0 +1,13 @@
+import { FlowLogics } from '@/models/questionnaires';
+
+import { FlowLogicEnum } from '../models/pogues';
+
+export function computePoguesFlowLogic(flowLogic?: FlowLogics): FlowLogicEnum {
+  switch (flowLogic) {
+    case FlowLogics.Redirection:
+      return FlowLogicEnum.Redirection;
+    case FlowLogics.Filter:
+    default:
+      return FlowLogicEnum.Filter;
+  }
+}

next/src/api/utils/formulasLanguage.test.ts

@@ -0,0 +1,17 @@
+import { FormulasLanguages } from '@/models/questionnaires';
+
+import { FormulasLanguageEnum } from '../models/pogues';
+import { computePoguesFormulasLanguage } from './formulasLanguage';
+
+describe('computePoguesFormulasLanguage', () => {
+  it.each([
+    [FormulasLanguages.VTL, FormulasLanguageEnum.VTL],
+    [FormulasLanguages.XPath, FormulasLanguageEnum.XPath],
+  ])('%s -> %s', (input, expected) => {
+    expect(computePoguesFormulasLanguage(input)).toEqual(expected);
+  });
+
+  it('works with default', () => {
+    expect(computePoguesFormulasLanguage()).toEqual(FormulasLanguageEnum.VTL);
+  });
+});

next/src/api/utils/formulasLanguage.ts

@@ -0,0 +1,15 @@
+import { FormulasLanguages } from '@/models/questionnaires';
+
+import { FormulasLanguageEnum } from '../models/pogues';
+
+export function computePoguesFormulasLanguage(
+  formulasLanguage?: FormulasLanguages,
+): FormulasLanguageEnum {
+  switch (formulasLanguage) {
+    case FormulasLanguages.XPath:
+      return FormulasLanguageEnum.XPath;
+    case FormulasLanguages.VTL:
+    default:
+      return FormulasLanguageEnum.VTL;
+  }
+}