@wger-project/react-components 25.10.16

package/src/services/config.test.ts

@@ -0,0 +1,213 @@
+import {
+    addMaxRepetitionsConfig,
+    addMaxRestConfig,
+    addMaxWeightConfig,
+    addNrOfSetsConfig,
+    addRepetitionsConfig,
+    addRestConfig,
+    addRirConfig,
+    addWeightConfig,
+    deleteMaxRepetitionsConfig,
+    deleteMaxRestConfig,
+    deleteMaxWeightConfig,
+    deleteNrOfSetsConfig,
+    deleteRepetitionsConfig,
+    deleteRestConfig,
+    deleteRirConfig,
+    deleteWeightConfig,
+    editMaxRepetitionsConfig,
+    editMaxRestConfig,
+    editMaxWeightConfig,
+    editNrOfSetsConfig,
+    editRepetitionsConfig,
+    editRestConfig,
+    editRirConfig,
+    editWeightConfig
+} from "services";
+import {
+    addBaseConfig,
+    AddBaseConfigParams,
+    deleteBaseConfig,
+    editBaseConfig,
+    EditBaseConfigParams
+} from "services/base_config";
+import { ApiPath } from "utils/consts";
+
+jest.mock("services/base_config", () => {
+    const originalModule = jest.requireActual("services/base_config");
+    return {
+        __esModule: true,
+        ...originalModule, // Include all original exports
+        editBaseConfig: jest.fn(),
+        addBaseConfig: jest.fn(),
+        deleteBaseConfig: jest.fn(),
+    };
+});
+
+describe('Config Service - Edit Functions', () => {
+    const mockEditData: EditBaseConfigParams = { id: 1, value: 10 };
+    // eslint-disable-next-line camelcase
+    const mockAddData: AddBaseConfigParams = { value: 10, slot_entry: 1 };
+
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        (editBaseConfig as jest.Mock).mockResolvedValue({ data: mockEditData });
+        (addBaseConfig as jest.Mock).mockResolvedValue({ id: 2, value: 200 });
+        (deleteBaseConfig as jest.Mock).mockResolvedValue(undefined);
+
+    });
+
+    it('should call editBaseConfig with correct params for editWeightConfig', async () => {
+        await editWeightConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.WEIGHT_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addWeightConfig', async () => {
+        await addWeightConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.WEIGHT_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteWeightConfig', async () => {
+        const id = 1;
+        await deleteWeightConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.WEIGHT_CONFIG);
+    });
+
+    it('should call editBaseConfig with correct params for editMaxWeightConfig', async () => {
+        await editMaxWeightConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.MAX_WEIGHT_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addMaxWeightConfig', async () => {
+        await addMaxWeightConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.MAX_WEIGHT_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteMaxWeightConfig', async () => {
+        const id = 1;
+        await deleteMaxWeightConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.MAX_WEIGHT_CONFIG);
+    });
+
+    it('should call editBaseConfig with correct params for editRepsConfig', async () => {
+        await editRepetitionsConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.REPETITIONS_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addRepsConfig', async () => {
+        await addRepetitionsConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.REPETITIONS_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteRepsConfig', async () => {
+        const id = 1;
+        await deleteRepetitionsConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.REPETITIONS_CONFIG);
+    });
+
+    it('should call editBaseConfig with correct params for editMaxRepsConfig', async () => {
+        await editMaxRepetitionsConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.MAX_REPS_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addMaxRepsConfig', async () => {
+        await addMaxRepetitionsConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.MAX_REPS_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteMaxRepsConfig', async () => {
+        const id = 1;
+        await deleteMaxRepetitionsConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.MAX_REPS_CONFIG);
+    });
+
+    it('should call editBaseConfig with correct params for editNrOfSetsConfig', async () => {
+        await editNrOfSetsConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.NR_OF_SETS_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addNrOfSetsConfig', async () => {
+        await addNrOfSetsConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.NR_OF_SETS_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteNrOfSetsConfig', async () => {
+        const id = 1;
+        await deleteNrOfSetsConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.NR_OF_SETS_CONFIG);
+    });
+
+    it('should call editBaseConfig with correct params for editRirConfig', async () => {
+        await editRirConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.RIR_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addRirConfig', async () => {
+        await addRirConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.RIR_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteRirConfig', async () => {
+        const id = 1;
+        await deleteRirConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.RIR_CONFIG);
+    });
+
+    it('should call editBaseConfig with correct params for editRestConfig', async () => {
+        await editRestConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.REST_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addRestConfig', async () => {
+        await addRestConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.REST_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteRestConfig', async () => {
+        const id = 1;
+        await deleteRestConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.REST_CONFIG);
+    });
+
+    it('should call editBaseConfig with correct params for editMaxRestConfig', async () => {
+        await editMaxRestConfig(mockEditData);
+        expect(editBaseConfig).toHaveBeenCalledTimes(1);
+        expect(editBaseConfig).toHaveBeenCalledWith(mockEditData, ApiPath.MAX_REST_CONFIG);
+    });
+
+    it('should call addBaseConfig with correct params for addMaxRestConfig', async () => {
+        await addMaxRestConfig(mockAddData);
+        expect(addBaseConfig).toHaveBeenCalledTimes(1);
+        expect(addBaseConfig).toHaveBeenCalledWith(mockAddData, ApiPath.MAX_REST_CONFIG);
+    });
+
+    it('should call deleteBaseConfig with correct params for deleteMaxRestConfig', async () => {
+        const id = 1;
+        await deleteMaxRestConfig(id);
+        expect(deleteBaseConfig).toHaveBeenCalledTimes(1);
+        expect(deleteBaseConfig).toHaveBeenCalledWith(id, ApiPath.MAX_REST_CONFIG);
+    });
+});

package/src/services/config.ts

@@ -0,0 +1,50 @@
+import {
+    addBaseConfig,
+    AddBaseConfigParams,
+    deleteBaseConfig,
+    editBaseConfig,
+    EditBaseConfigParams
+} from "services/base_config";
+import { ApiPath } from "utils/consts";
+
+
+export const editWeightConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.WEIGHT_CONFIG);
+export const addWeightConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.WEIGHT_CONFIG);
+export const deleteWeightConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.WEIGHT_CONFIG);
+
+export const editMaxWeightConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.MAX_WEIGHT_CONFIG);
+export const addMaxWeightConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.MAX_WEIGHT_CONFIG);
+export const deleteMaxWeightConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.MAX_WEIGHT_CONFIG);
+
+export const editRepetitionsConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.REPETITIONS_CONFIG);
+export const addRepetitionsConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.REPETITIONS_CONFIG);
+export const deleteRepetitionsConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.REPETITIONS_CONFIG);
+
+export const editMaxRepetitionsConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.MAX_REPS_CONFIG);
+export const addMaxRepetitionsConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.MAX_REPS_CONFIG);
+export const deleteMaxRepetitionsConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.MAX_REPS_CONFIG);
+
+export const editNrOfSetsConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.NR_OF_SETS_CONFIG);
+export const addNrOfSetsConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.NR_OF_SETS_CONFIG);
+export const deleteNrOfSetsConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.NR_OF_SETS_CONFIG);
+
+export const editMaxNrOfSetsConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.MAX_NR_OF_SETS_CONFIG);
+export const addMaxNrOfSetsConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.MAX_NR_OF_SETS_CONFIG);
+export const deleteMaxNrOfSetsConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.MAX_NR_OF_SETS_CONFIG);
+
+export const editRirConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.RIR_CONFIG);
+export const addRirConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.RIR_CONFIG);
+export const deleteRirConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.RIR_CONFIG);
+
+export const editMaxRirConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.MAX_RIR_CONFIG);
+export const addMaxRirConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.MAX_RIR_CONFIG);
+export const deleteMaxRirConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.MAX_RIR_CONFIG);
+
+export const editRestConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.REST_CONFIG);
+export const addRestConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.REST_CONFIG);
+export const deleteRestConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.REST_CONFIG);
+
+export const editMaxRestConfig = async (data: EditBaseConfigParams) => await editBaseConfig(data, ApiPath.MAX_REST_CONFIG);
+export const addMaxRestConfig = async (data: AddBaseConfigParams) => await addBaseConfig(data, ApiPath.MAX_REST_CONFIG);
+export const deleteMaxRestConfig = async (id: number) => await deleteBaseConfig(id, ApiPath.MAX_REST_CONFIG);
+

package/src/services/day.test.ts

@@ -0,0 +1,118 @@
+import axios from "axios";
+import { Day } from "components/WorkoutRoutines/models/Day";
+import { addDay, deleteDay, editDay } from "services";
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('editDay', () => {
+
+    const mockDayData = {
+        id: 1,
+        routine: 1,
+        name: 'Test Day',
+        description: 'A test day',
+        order: 1,
+        // eslint-disable-next-line camelcase
+        is_rest: false,
+    };
+
+    const testDay = Day.fromJson(mockDayData);
+    testDay.name = 'Test Day';
+
+    beforeEach(() => {
+        // Reset mocks before each test
+        jest.clearAllMocks();
+    });
+
+    test('should update a day and return the updated day', async () => {
+        mockedAxios.patch.mockResolvedValue({ data: mockDayData });
+
+        const updatedDay = await editDay(testDay);
+
+        expect(axios.patch).toHaveBeenCalledTimes(1);
+        expect(updatedDay).toEqual(Day.fromJson(mockDayData));
+    });
+
+    test('should handle errors gracefully', async () => {
+        const errorMessage = 'Network Error';
+        mockedAxios.patch.mockRejectedValue(new Error(errorMessage));
+
+        await expect(editDay(testDay)).rejects.toThrow(errorMessage);
+        expect(axios.patch).toHaveBeenCalledTimes(1);
+    });
+});
+
+
+describe('addDay', () => {
+    const mockDayData = {
+        id: 1,
+        routine: 1,
+        name: 'Test Day',
+        description: 'A test day',
+        order: 1,
+        // eslint-disable-next-line camelcase
+        is_rest: false,
+        // eslint-disable-next-line camelcase
+        need_logs_to_advance: false,
+    };
+
+    const testDay = new Day({
+        routineId: 1,
+        name: 'Test Day',
+        description: 'A test day',
+        order: 1,
+        isRest: false,
+        needLogsToAdvance: false,
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('should create a new day and return the created day', async () => {
+        mockedAxios.post.mockResolvedValue({ data: mockDayData });
+
+        const newDay = await addDay(testDay);
+
+        expect(axios.post).toHaveBeenCalledTimes(1);
+        expect(newDay).toEqual(Day.fromJson(mockDayData));
+    });
+
+    test('should handle errors gracefully', async () => {
+        const errorMessage = 'Network Error';
+        mockedAxios.post.mockRejectedValue(new Error(errorMessage));
+
+        await expect(addDay(testDay)).rejects.toThrow(errorMessage);
+        expect(axios.post).toHaveBeenCalledTimes(1);
+    });
+});
+
+
+describe('deleteDay', () => {
+    const mockDayId = 1;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('should delete a day', async () => {
+        mockedAxios.delete.mockResolvedValue({ status: 204 }); // Assuming a successful delete returns 204 No Content
+
+        await deleteDay(mockDayId);
+
+        expect(axios.delete).toHaveBeenCalledTimes(1);
+        expect(axios.delete).toHaveBeenCalledWith(
+            expect.any(String),
+            expect.any(Object)
+        );
+    });
+
+    test('should handle errors gracefully', async () => {
+        const errorMessage = 'Network Error';
+        mockedAxios.delete.mockRejectedValue(new Error(errorMessage));
+
+        await expect(deleteDay(mockDayId)).rejects.toThrow(errorMessage);
+        expect(axios.delete).toHaveBeenCalledTimes(1);
+    });
+});

package/src/services/day.ts

@@ -0,0 +1,44 @@
+import axios from 'axios';
+import { Day } from "components/WorkoutRoutines/models/Day";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+
+
+/*
+ * Update a day
+ */
+export const editDay = async (day: Day): Promise<Day> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.DAY, { id: day.id! }),
+        day.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Day.fromJson(response.data);
+};
+
+
+/*
+ * Creates a new day
+ */
+export const addDay = async (day: Day): Promise<Day> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.DAY),
+        day.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Day.fromJson(response.data);
+};
+
+/*
+ * Deletes an existing day
+ */
+export const deleteDay = async (id: number): Promise<void> => {
+    await axios.delete(
+        makeUrl(ApiPath.DAY, { id: id }),
+        { headers: makeHeader() }
+    );
+};
+
+

package/src/services/equipment.test.ts

@@ -0,0 +1,46 @@
+import axios from "axios";
+import { Equipment } from "components/Exercises/models/equipment";
+import { getEquipment } from "services";
+
+jest.mock("axios");
+
+
+describe("equipment service tests", () => {
+
+    test('GET equipment entries', async () => {
+
+        // Arrange
+        const response = {
+            count: 3,
+            next: null,
+            previous: null,
+            results: [
+                {
+                    "id": 1,
+                    "name": "Barbell"
+                },
+                {
+                    "id": 8,
+                    "name": "Bench"
+                },
+                {
+                    "id": 3,
+                    "name": "Dumbbell"
+                },
+            ]
+        };
+
+
+        // Act
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: response }));
+        const result = await getEquipment();
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toStrictEqual([
+            new Equipment(1, "Barbell"),
+            new Equipment(8, "Bench"),
+            new Equipment(3, "Dumbbell"),
+        ]);
+    });
+});

package/src/services/equipment.ts

@@ -0,0 +1,20 @@
+import axios from 'axios';
+import { Equipment, EquipmentAdapter } from "components/Exercises/models/equipment";
+import { ApiEquipmentType } from 'types';
+import { makeHeader, makeUrl } from "utils/url";
+import { ResponseType } from "./responseType";
+
+export const EQUIPMENT_PATH = 'equipment';
+
+
+/*
+ * Fetch all equipment
+ */
+export const getEquipment = async (): Promise<Equipment[]> => {
+    const url = makeUrl(EQUIPMENT_PATH);
+    const { data: receivedEquipment } = await axios.get<ResponseType<ApiEquipmentType>>(url, {
+        headers: makeHeader(),
+    });
+    const adapter = new EquipmentAdapter();
+    return receivedEquipment.results.map(e => adapter.fromJson(e));
+};

package/src/services/exercise.test.ts

@@ -0,0 +1,98 @@
+import axios from "axios";
+import { deleteExercise, editExercise, getExercise, getExercises, processExerciseApiData } from "services";
+import { responseApiExerciseInfo, testApiExercise1 } from "tests/responseApi";
+
+jest.mock("axios");
+
+describe("Exercise service API tests", () => {
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    test('GET exercise data entries', async () => {
+
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: responseApiExerciseInfo }));
+
+        // Act
+        const result = await getExercises();
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toEqual([testApiExercise1]);
+    });
+
+    test('GET exercise data for single entry', async () => {
+
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: responseApiExerciseInfo.results[0] }));
+
+        // Act
+        const result = await getExercise(345);
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(testApiExercise1);
+    });
+
+    test('EDIT an existing exercise', async () => {
+
+        // Arrange
+        const response = {
+            "id": 749,
+            "uuid": "1b020b3a-3732-4c7e-92fd-a0cec90ed69b",
+            "creation_date": "2022-06-23",
+            "update_date": "2022-06-23T18:22:54.909478+02:00",
+            "category": 3,
+            "muscles": [3, 4],
+            "muscles_secondary": [9],
+            "equipment": [1, 2],
+            "variations": null
+        };
+        (axios.patch as jest.Mock).mockImplementation(() => Promise.resolve({ data: response, status: 200 }));
+
+        // Act
+        const result = await editExercise(
+            749,
+            {
+                category: 3,
+                equipment: [1, 2],
+                muscles: [3, 4],
+                // eslint-disable-next-line camelcase
+                muscles_secondary: [9]
+            }
+        );
+
+        // Assert
+        expect(axios.patch).toHaveBeenCalled();
+        expect(result).toEqual(200);
+    });
+
+    test('DELETE exercise', async () => {
+
+        // Arrange
+        (axios.delete as jest.Mock).mockImplementation(() => Promise.resolve({ status: 204 }));
+
+        // Act
+        const result = await deleteExercise(1);
+
+        // Assert
+        expect(axios.delete).toHaveBeenCalled();
+        expect(result).toEqual(204);
+    });
+
+});
+
+
+describe("Exercise service parser tests", () => {
+
+    test('process api data', () => {
+
+        // Act
+        const result = processExerciseApiData(responseApiExerciseInfo);
+
+        // Assert
+        expect(result).toEqual([testApiExercise1]);
+    });
+});