fix: #ENABLING-1202 retire la dépendance directe à axios, adopte le bridge http d'entcore-toolkit

common/src/main/resources/ts/model/Student.ts

@@ -1,5 +1,5 @@
 import {_, notify} from 'entcore';
-import http from 'axios';
+import { http } from 'entcore-toolkit';
 import {IStructure} from "@common/model/Viescolaire";
 import {IAudience} from "@common/model/Audience";
 

common/src/main/resources/ts/services/GroupService.ts

@@ -1,5 +1,5 @@
 import {ng} from 'entcore'
-import http from 'axios';
+import { http } from 'entcore-toolkit';
 import {User} from '@common/model/User';
 import {SearchItem} from "@common/services/SearchService";
 import {StudentDivisionResponse} from "@common/model/grouping";

common/src/main/resources/ts/services/SearchService.ts

@@ -1,5 +1,5 @@
 import {ng} from 'entcore';
-import http from 'axios';
+import { http } from 'entcore-toolkit';
 import {User} from '@common/model/User';
 
 export interface SearchItem {

common/src/main/resources/ts/services/TimeslotClasseService.ts

@@ -1,39 +1,39 @@
 import {ng} from "entcore";
-import http, {AxiosResponse} from "axios";
+import { http, HttpResponse } from 'entcore-toolkit';
 import {IStructureSlot} from "@common/model";
 
 interface TimeslotClasseService {
     getAudienceTimeslot(audienceId: string): Promise<IStructureSlot>;
 
     getAllClassFromTimeslot(timeslotId: string): Promise<string[]>;
 
-    createOrUpdateClassTimeslot(timeslotId: string, classId: string): Promise<AxiosResponse>;
+    createOrUpdateClassTimeslot(timeslotId: string, classId: string): Promise<HttpResponse>;
 
-    deleteClassTimeslot(classId: string): Promise<AxiosResponse>;
+    deleteClassTimeslot(classId: string): Promise<HttpResponse>;
 
-    deleteAllAudienceFromTimeslot(timeslotId: string): Promise<AxiosResponse>;
+    deleteAllAudienceFromTimeslot(timeslotId: string): Promise<HttpResponse>;
 }
 
 export const timeslotClasseService: TimeslotClasseService =  {
     async getAudienceTimeslot(audienceId: string): Promise<IStructureSlot> {
-        const {data}: AxiosResponse = await http.get(`/viescolaire/timeslot/audience/${audienceId}`);
+        const {data}: HttpResponse = await http.get(`/viescolaire/timeslot/audience/${audienceId}`);
         return data as IStructureSlot;
     },
 
     async getAllClassFromTimeslot(timeslotId: string): Promise<string[]> {
-        const {data}: AxiosResponse = await http.get(`/viescolaire/timeslot/${timeslotId}`);
+        const {data}: HttpResponse = await http.get(`/viescolaire/timeslot/${timeslotId}`);
         return data as string[];
     },
 
-    async createOrUpdateClassTimeslot(timeslotId: string, classId: string): Promise<AxiosResponse> {
+    async createOrUpdateClassTimeslot(timeslotId: string, classId: string): Promise<HttpResponse> {
         return http.post(`/viescolaire/timeslot/audience`, {timeslot_id: timeslotId, class_id: classId});
     },
 
-    async deleteAllAudienceFromTimeslot(timeslotId: string): Promise<AxiosResponse> {
+    async deleteAllAudienceFromTimeslot(timeslotId: string): Promise<HttpResponse> {
         return http.delete(`/viescolaire/timeslot/${timeslotId}`);
     },
 
-    async deleteClassTimeslot(classId: string): Promise<AxiosResponse> {
+    async deleteClassTimeslot(classId: string): Promise<HttpResponse> {
         return http.delete(`/viescolaire/timeslot/audience/${classId}`);
     }
 }

common/src/main/resources/ts/services/UserService.ts

@@ -1,5 +1,5 @@
 import {ng} from 'entcore'
-import http from 'axios';
+import { http } from 'entcore-toolkit';
 import {Student} from "@common/model/Student";
 
 export interface IUserService {

common/src/main/resources/ts/services/ViescolaireService.ts

@@ -1,6 +1,6 @@
 import {model, ng} from 'entcore'
 import {ISchoolYearPeriod, IStructure, IStructureSlot} from "../model";
-import http from "axios";
+import { http } from 'entcore-toolkit';
 import {Student} from "@common/model/Student";
 
 declare let window: any;

common/src/main/resources/ts/services/__tests__/search.service.test.ts

@@ -1,38 +1,41 @@
-// tricks to fake "mock" entcore ng class in order to use service
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
+jest.mock('entcore-toolkit', () => ({
+    ...jest.requireActual('entcore-toolkit'),
+    http: {get: jest.fn(), post: jest.fn(), put: jest.fn(), delete: jest.fn(), postFile: jest.fn(), putFile: jest.fn()}
+}));
+
+import {http} from 'entcore-toolkit';
+import {mockHttpResponse} from '@test-utils/httpMock';
 import {SearchService, searchService} from "@common/services";
 
 describe('TimeslotClasseService', () => {
     it('returns data when API request is correctly called for search method', done => {
-        var mock = new MockAdapter(axios);
         const data = [{type: "USER", displayName: "displayName1", groupName: "groupName1"},
             {type: "GROUP", displayName: "displayName2", groupName: "groupName2"}];
         const structureId = "sturctureId";
         const value = "value";
-
-        mock.onGet(`/presences/search?structureId=${structureId}&q=${value}`).reply(200, data);
+        const url = `/presences/search?structureId=${structureId}&q=${value}`;
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         SearchService.search(structureId, value).then(res => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(res[0].toString()).toEqual("displayName1 - groupName1");
             expect(res[1].toString()).toEqual("displayName2");
             done();
         });
     });
 
     it('returns data when API request is correctly called for searchUser method', done => {
-        var mock = new MockAdapter(axios);
         const data = [{idClasse: ["3184$3EME1", "3487$3EME2"], classesNames: ["3EME2", "3EME1"], displayName: "displayName1"},
             {idClasse: ["AMIENS-2588141165", "AMIENS-1689416"], classesNames: ["CP", "CM1"], displayName: "displayName2"},
             {displayName: "displayName3"}];
         const structureId = "sturctureId";
         const value = "value";
         const profile = "profile";
-
-        mock.onGet(`/presences/search/users?structureId=${structureId}&profile=${profile}&q=${value}&field=firstName&field=lastName`)
-            .reply(200, data);
+        const url = `/presences/search/users?structureId=${structureId}&profile=${profile}&q=${value}&field=firstName&field=lastName`;
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         SearchService.searchUser(structureId, value, profile).then((res: Array<any>) => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(res[0].toString()).toEqual("displayName1 - 3EME1,3EME2");
             expect(res[1].toString()).toEqual("displayName2 - CM1,CP");
             expect(res[2].toString()).toEqual("displayName3");
@@ -46,17 +49,16 @@ describe('TimeslotClasseService', () => {
     });
 
     it('returns data when API request is correctly called for searchStudents method', done => {
-        var mock = new MockAdapter(axios);
         const data = [{idClasse: ["3184$3EME1", "3487$3EME2"], classesNames: ["3EME2", "3EME1"], displayName: "displayName1"},
             {idClasse: ["AMIENS-2588141165", "AMIENS-1689416"], classesNames: ["CP", "CM1"], displayName: "displayName2"},
             {displayName: "displayName3"}];
         const structureId = "sturctureId";
         const value = "value";
-
-        mock.onGet(`/presences/search/students?structureId=${structureId}&q=${value}&field=firstName&field=lastName`)
-            .reply(200, data);
+        const url = `/presences/search/students?structureId=${structureId}&q=${value}&field=firstName&field=lastName`;
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         SearchService.searchStudents(structureId, value).then((res: Array<any>) => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(res[0].toString()).toEqual("displayName1 - 3EME1,3EME2");
             expect(res[1].toString()).toEqual("displayName2 - CM1,CP");
             expect(res[2].toString()).toEqual("displayName3");
@@ -68,4 +70,4 @@ describe('TimeslotClasseService', () => {
             done();
         });
     });
-});
+});

common/src/main/resources/ts/services/__tests__/timeslot-classe.service.test.ts

@@ -1,31 +1,35 @@
-// tricks to fake "mock" entcore ng class in order to use service
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
+jest.mock('entcore-toolkit', () => ({
+    ...jest.requireActual('entcore-toolkit'),
+    http: {get: jest.fn(), post: jest.fn(), put: jest.fn(), delete: jest.fn(), postFile: jest.fn(), putFile: jest.fn()}
+}));
+
+import {http} from 'entcore-toolkit';
+import {mockHttpResponse} from '@test-utils/httpMock';
 import {timeslotClasseService, TimeslotClasseService} from "@common/services/TimeslotClasseService";
 import {IStructureSlot} from "@common/model";
 
 describe('TimeslotClasseService', () => {
     it('returns data when API request is correctly called for getAudienceTimeslot method', done => {
         const audienceId = "audienceId";
-        var mock = new MockAdapter(axios);
         const data: IStructureSlot = {_id: "", name: "", slots: []};
-
-        mock.onGet(`/viescolaire/timeslot/audience/${audienceId}`).reply(200, data);
+        const url = `/viescolaire/timeslot/audience/${audienceId}`;
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         timeslotClasseService.getAudienceTimeslot("audienceId").then(response => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(response).toEqual(data);
             done();
         });
     });
 
     it('returns data when API request is correctly called for getAllClassFromTimeslot method', done => {
         const timeslotId = "timeslotId";
-        var mock = new MockAdapter(axios);
         const data = ["ok"];
-
-        mock.onGet(`/viescolaire/timeslot/${timeslotId}`).reply(200, data);
+        const url = `/viescolaire/timeslot/${timeslotId}`;
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         timeslotClasseService.getAllClassFromTimeslot("timeslotId").then(response => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(response).toEqual(data);
             done();
         });
@@ -34,44 +38,49 @@ describe('TimeslotClasseService', () => {
     it('returns data when API request is correctly called for createOrUpdateClassTimeslot method', done => {
         const timeslotId = "timeslotId";
         const classId = "classId";
-        var mock = new MockAdapter(axios);
         const data = {response: true};
-
-        mock.onPost(`/viescolaire/timeslot/audience`, {timeslot_id: timeslotId, class_id: classId}).reply(200, data);
+        const url = `/viescolaire/timeslot/audience`;
+        const body = {timeslot_id: timeslotId, class_id: classId};
+        (http.post as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {
+            url,
+            method: 'post',
+            data: JSON.stringify(body)
+        }));
 
         timeslotClasseService.createOrUpdateClassTimeslot("timeslotId", "classId").then(response => {
+            expect(http.post).toHaveBeenCalledWith(url, body);
             expect(response.data).toEqual(data);
-            expect(response.config.url).toEqual(`/viescolaire/timeslot/audience`);
-            expect(response.config.data).toEqual(JSON.stringify({timeslot_id: timeslotId, class_id: classId}));
+            expect((response.config as any).url).toEqual(`/viescolaire/timeslot/audience`);
+            expect((response.config as any).data).toEqual(JSON.stringify({timeslot_id: timeslotId, class_id: classId}));
             done();
         });
     });
 
     it('returns data when API request is correctly called for deleteAllAudienceFromTimeslot method', done => {
         const timeslotId = "timeslotId";
-        var mock = new MockAdapter(axios);
         const data = {response: true};
-
-        mock.onDelete(`/viescolaire/timeslot/${timeslotId}`).reply(200, data);
+        const url = `/viescolaire/timeslot/${timeslotId}`;
+        (http.delete as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url, method: 'delete'}));
 
         timeslotClasseService.deleteAllAudienceFromTimeslot("timeslotId").then(response => {
+            expect(http.delete).toHaveBeenCalledWith(url);
             expect(response.data).toEqual(data);
-            expect(response.config.url).toEqual(`/viescolaire/timeslot/${timeslotId}`);
+            expect((response.config as any).url).toEqual(`/viescolaire/timeslot/${timeslotId}`);
             done();
         });
     });
 
     it('returns data when API request is correctly called for getAudienceTimeslot method', done => {
         const classId = "classId";
-        var mock = new MockAdapter(axios);
         const data = {response: true};
-
-        mock.onDelete(`/viescolaire/timeslot/audience/${classId}`).reply(200, data);
+        const url = `/viescolaire/timeslot/audience/${classId}`;
+        (http.delete as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url, method: 'delete'}));
 
         timeslotClasseService.deleteClassTimeslot("classId").then(response => {
+            expect(http.delete).toHaveBeenCalledWith(url);
             expect(response.data).toEqual(data);
-            expect(response.config.url).toEqual(`/viescolaire/timeslot/audience/${classId}`);
+            expect((response.config as any).url).toEqual(`/viescolaire/timeslot/audience/${classId}`);
             done();
         });
     });
-});
+});

common/src/main/resources/ts/services/__tests__/viescolaire.service.test.ts

@@ -1,30 +1,37 @@
 // tricks to fake "mock" entcore ng class in order to use service
 import {model, ng} from "@presences/models/__mocks__/entcore";
 
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
+jest.mock('entcore-toolkit', () => ({
+    ...jest.requireActual('entcore-toolkit'),
+    http: {get: jest.fn(), post: jest.fn(), put: jest.fn(), delete: jest.fn(), postFile: jest.fn(), putFile: jest.fn()}
+}));
+
+import {http} from 'entcore-toolkit';
+import {mockHttpResponse} from '@test-utils/httpMock';
 import {ViescolaireService} from "../ViescolaireService";
 import {IStructure} from "@common/model";
 
 describe('ViescolaireService', () => {
     it('returns data when API request is correctly called for getSchoolYearDates method', done => {
         const structureId = "structureId";
-        var mock = new MockAdapter(axios);
         const data = {response: true};
-        mock.onGet('viescolaire/settings/periode/schoolyear?structureId='+structureId).reply(200, data);
+        const url = 'viescolaire/settings/periode/schoolyear?structureId=' + structureId;
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         ViescolaireService.getSchoolYearDates("structureId").then(response => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(response).toEqual(data);
             done();
         });
     });
 
     it('returns data when API request is correctly called for getSlotProfile method', done => {
-        var mock = new MockAdapter(axios);
         const data = {response: true};
-        mock.onGet('/viescolaire/structures/structureId/time-slot').reply(200, data);
+        const url = '/viescolaire/structures/structureId/time-slot';
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         ViescolaireService.getSlotProfile("structureId").then(response => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(response).toEqual(data);
             done();
         });
@@ -33,20 +40,18 @@ describe('ViescolaireService', () => {
     it('returns data when API request is correctly called for getStudent method', done => {
         const structureId = "structureId";
         const studentId = "studentId";
-        var mock = new MockAdapter(axios);
         const data = {response: true};
-        mock.onGet(`viescolaire/eleves?idUser=${studentId}&idStructure=${structureId}`).reply(200, data);
+        const url = `viescolaire/eleves?idUser=${studentId}&idStructure=${structureId}`;
+        (http.get as jest.Mock).mockResolvedValueOnce(mockHttpResponse(data, {url}));
 
         ViescolaireService.getStudent("structureId", "studentId").then(response => {
+            expect(http.get).toHaveBeenCalledWith(url);
             expect(response).toEqual(data);
             done();
         });
     });
 
     it('returns data when API request is correctly called for getBuildOwnStructure method', done => {
-        var mock = new MockAdapter(axios);
-        const data = {response: true};
-
         const structure1: IStructure = {id: "id1", name: "name1"}
         const structure2: IStructure = {id: "id2", name: "name2"}
         const expected: Array<IStructure> = [structure1, structure2];
@@ -57,8 +62,7 @@ describe('ViescolaireService', () => {
         model.me.structureNames.push("name1");
         model.me.structureNames.push("name2");
 
-        mock.onGet('/viescolaire/structures/structureId/time-slot').reply(200, data);
         expect(ViescolaireService.getBuildOwnStructure()).toEqual(expected);
         done();
     });
-});
+});

common/src/main/resources/ts/services/grouping.service.ts

@@ -1,6 +1,6 @@
 import {Grouping, GroupingResponse} from "@common/model/grouping";
 import {ng} from "entcore";
-import http from "axios";
+import { http } from 'entcore-toolkit';
 
 export interface GroupingService {
     search(structureId: string, value: string): Promise<Grouping[]>;

common/src/main/resources/ts/services/screeb.service.ts

@@ -1,5 +1,5 @@
 import {appPrefix, model, ng, Service} from 'entcore';
-import http from 'axios';
+import { http } from 'entcore-toolkit';
 import {
     eventTrack,
     identityProperties,

incidents/src/main/resources/public/ts/directives/punishment-form/punishment-detention-form.ts

@@ -12,7 +12,7 @@ import {User} from "@common/model/User";
 import {SearchService} from "@common/services";
 import {PeriodFormUtils} from "@common/utils/periodForm";
 import {ROOTS} from "@incidents/core/const/roots";
-import {AxiosError} from "axios";
+import { HttpError } from 'entcore-toolkit';
 import {punishmentService} from "@incidents/services";
 
 declare let window: any;
@@ -231,7 +231,7 @@ export const PunishmentDetentionForm = ng.directive('punishmentDetentionForm', [
                     if (vm.editmode && detentionSlotToDelete.detentionField.id) {
                         punishmentService.delete(detentionSlotToDelete.detentionField.id, window.structure.id)
                             .then(() => toasts.confirm(lang.translate('incidents.punishment.delete.succeed')))
-                            .catch((e: AxiosError) => toasts.warning(e.response ? e.response.data : e.message));
+                            .catch((e: HttpError) => toasts.warning(e.response ? e.response.data : e.message));
                     }
                 }
 

incidents/src/main/resources/public/ts/models/incidents/Incidents.ts

@@ -1,5 +1,4 @@
-import http from 'axios';
-import {Mix} from 'entcore-toolkit';
+import {Mix, http} from 'entcore-toolkit';
 import {DateUtils} from '@common/utils'
 import {LoadingCollection} from '@common/model'
 import {IncidentType, Partner, Place, ProtagonistType, Seriousness} from "../../services";