@hedia/recommendation-screen 2.1.34-alpha.9 → 2.1.34

package/src/__tests__/Validations.test.js

@@ -1,465 +0,0 @@
-import { Activity, BloodGlucoseUnit, BloodKetonesUnit, BolusCalculator, Languages, Milliseconds, UserSettings, } from "@hedia/types";
-import { FOUR_HOURS_SECONDS } from "../utils/Constants";
-import * as Errors from "../utils/RecommendationError";
-import * as Validations from "../utils/Validations";
-import { generateDefaultActivitySettings, generateDefaultLogbook } from "./utils";
-const ActivityEnum = Activity.Enums.ActivityEnum;
-const ActivityIntensity = Activity.Enums.ActivityIntensity;
-const InjectionMethod = UserSettings.Enums.InjectionMethod;
-const { light, moderate, hard } = ActivityIntensity;
-describe(`Test validations functions for the recommendation props`, () => {
-    test.each `
-		validInjectionMethod
-		${InjectionMethod.PenHalf}
-		${InjectionMethod.PenWhole}
-		${InjectionMethod.Pump}
-	`(`Validation checking on treatment types $validInjectionMethod `, ({ validInjectionMethod }) => {
-        expect(() => Validations.checkInjectionMethod(validInjectionMethod)).not.toThrowError(Errors.InjectionMethodError());
-    });
-    test.each `
-		invalidInjectionMethod
-		${`Pen`}
-		${`Injection`}
-		${`Hedia`}
-	`(`Validation checking on treatment types $invalidInjectionMethod throws error`, (invalidInjectionMethod) => {
-        expect(() => Validations.checkInjectionMethod(invalidInjectionMethod)).toThrowError(Errors.InjectionMethodError());
-    });
-    test.each `
-		validUnit
-		${BloodGlucoseUnit.MG_DL}
-		${BloodGlucoseUnit.MMOL_L}
-	`(`Validation checking on blood glucose unit types $validUnit`, ({ validUnit }) => {
-        expect(() => Validations.checkBGLUnit(validUnit)).not.toThrowError(Errors.BloodGlucoseUnitError());
-    });
-    test.each `
-		invalidUnit
-		${`Kilogram`}
-		${`Litre`}
-		${`MMOL`}
-	`(`Validation checking on invalid blood glucose unit types $invalidUnit throws error`, ({ invalidUnit }) => {
-        expect(() => Validations.checkBGLUnit(invalidUnit)).toThrowError(Errors.BloodGlucoseUnitError());
-    });
-    test.each `
-		validKetoneProps
-		${{ bloodKetoneUnit: BloodKetonesUnit.MG_DL, currentBKL: 0 }}
-		${{ bloodKetoneUnit: BloodKetonesUnit.MMOL_L, currentBKL: null }}
-		${{ bloodKetoneUnit: null, currentBKL: null }}
-	`(`Validation checking on valid blood ketones props $validKetoneProps`, ({ validKetoneProps }) => {
-        const { bloodKetoneUnit, currentBKL } = validKetoneProps;
-        expect(() => Validations.checkBKProps(bloodKetoneUnit, currentBKL)).not.toThrowError(Errors.BloodKetonePropsError());
-    });
-    test.each `
-		invalidKetoneProps
-		${{ bloodKetoneUnit: null, currentBKL: 0 }}
-		${{ bloodKetoneUnit: null, currentBKL: 8 }}
-	`(`Validation checking on invalid blood ketones props $invalidKetoneProps`, ({ invalidKetoneProps }) => {
-        const { bloodKetoneUnit, currentBKL } = invalidKetoneProps;
-        expect(() => Validations.checkBKProps(bloodKetoneUnit, currentBKL)).toThrowError(Errors.BloodKetonePropsError());
-    });
-    test.each `
-		validUnit
-		${BloodKetonesUnit.MG_DL}
-		${BloodKetonesUnit.MMOL_L}
-		${null}
-	`(`Validation checking on blood ketones unit types $validUnit`, ({ validUnit }) => {
-        expect(() => Validations.checkBKLUnit(validUnit)).not.toThrowError(Errors.BloodKetoneUnitError());
-    });
-    test.each `
-		invalidUnit
-		${`Kilogram`}
-		${`Litre`}
-		${`MMOL`}
-	`(`Validation checking on invalid blood ketones unit types $invalidUnit throws error`, ({ invalidUnit }) => {
-        expect(() => Validations.checkBKLUnit(invalidUnit)).toThrowError(Errors.BloodKetoneUnitError());
-    });
-    test.each `
-		validLanguage
-		${Languages.da}
-		${Languages.en}
-		${Languages.de}
-		${Languages.es}
-		${Languages.it}
-		${Languages.fr}
-	`(`Validation checking on supported languages types $validLanguage`, ({ validLanguage }) => {
-        expect(() => Validations.checkLanguage(validLanguage)).not.toThrowError(Errors.LanguageError());
-    });
-    test.each `
-		invalidLanguage
-		${`Polish`}
-		${`Danish`}
-		${`Dansk`}
-		${`Deutsch`}
-	`(`Validation checking on supported languages types $invalidLanguage throws error`, (invalidLanguage) => {
-        expect(() => Validations.checkLanguage(invalidLanguage)).toThrowError(Errors.LanguageError());
-    });
-    it.each `
-		validLatestLogbookFrom6Hours
-		${generateDefaultLogbook()}
-		${null}
-		${{ ...generateDefaultLogbook(), blood_glucose_millimolar: null }}
-	`(`Validation checking on the latest logbook from the latest 6 hours with a valid logbook`, ({ validLatestLogbookFrom6Hours }) => {
-        expect(() => Validations.checkLatestLogbook6Hours(validLatestLogbookFrom6Hours)).not.toThrowError(Errors.LatestLogbook6HoursBGLError());
-    });
-    it.each `
-		invalidLatestLogbookFrom6Hours
-		${undefined}
-		${{}}
-		${[]}
-		${{ ...generateDefaultLogbook(), blood_glucose_millimolar: 1 }}
-		${{ ...generateDefaultLogbook(), blood_glucose_millimolar: 33.4 }}
-	`(`Validation checking on the latest logbook from the latest 6 hours with an invalid logbook `, ({ invalidLatestLogbookFrom6Hours }) => {
-        expect(() => Validations.checkLatestLogbook6Hours(invalidLatestLogbookFrom6Hours)).toThrowError(Errors.LatestLogbook6HoursBGLError());
-    });
-    test.each `
-		validActivityType
-		${ActivityEnum.Walk}
-		${ActivityEnum.Swim}
-		${ActivityEnum.Run}
-		${ActivityEnum.Other}
-		${ActivityEnum.Cycling}
-	`(`Validation checking on activity types $validActivityType `, ({ validActivityType }) => {
-        expect(() => Validations.checkActivityType(validActivityType)).not.toThrowError(Errors.ActivityTypeError());
-    });
-    test.each `
-		invalidActivityType
-		${`Dance`}
-		${`Walking`}
-		${`Swimming`}
-		${`Running`}
-		${`Cycle`}
-	`(`Validation checking on activity types $invalidActivityType throws error`, (invalidActivityType) => {
-        expect(() => Validations.checkActivityType(invalidActivityType)).toThrowError(Errors.ActivityTypeError());
-    });
-    test.each `
-		validUserReminder
-		${0}
-		${6}
-		${3}
-		${4.5}
-	`(`Validation checking on the user reminder value $validUserReminder`, ({ validUserReminder: validUserReminder }) => {
-        expect(() => Validations.checkUserReminder(validUserReminder)).not.toThrowError(Errors.UserReminderError());
-    });
-    test.each `
-		invalidUserReminder
-		${-1}
-		${null}
-		${undefined}
-		${7}
-	`(`Validation checking on the user reminder value $invalidUserReminder throws error`, ({ invalidUserReminder }) => {
-        expect(() => Validations.checkUserReminder(invalidUserReminder)).toThrowError(Errors.UserReminderError());
-    });
-});
-describe(`Test validations for the calculator parameters`, () => {
-    test.each `
-		validDuration
-		${1}
-		${60}
-		${34}
-		${5.555}
-	`(`Validation checking on activity $validDuration `, ({ validDuration }) => {
-        expect(() => Validations.checkActivityDuration(validDuration)).not.toThrowError(Errors.ActivityDurationError());
-    });
-    test.each `
-		invalidDuration
-		${0}
-		${61}
-		${undefined}
-		${null}
-	`(`Validation checking on activity $invalidDuration throws error`, (invalidDuration) => {
-        expect(() => Validations.checkActivityDuration(invalidDuration)).toThrowError(Errors.ActivityDurationError());
-    });
-    test.each `
-		validIntensity
-		${hard}
-		${light}
-		${moderate}
-	`(`Validation checking on activity $validIntensity`, ({ validIntensity }) => {
-        expect(() => Validations.checkActivityIntensity(validIntensity)).not.toThrowError(Errors.ActivityIntensityError());
-    });
-    /**
-     * Gets an string and returns the string with the first letter capitalized
-     * @param text to capitalize
-     */
-    const capitalizeFirstLetter = (text) => {
-        return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
-    };
-    test.each `
-		invalidIntensity
-		${`bingo`}
-		${`easy`}
-		${undefined}
-		${null}
-		${`Low`}
-		${capitalizeFirstLetter(moderate)}
-	`(`Validation checking on activity $invalidIntensity throws error`, ({ invalidIntensity }) => {
-        expect(() => Validations.checkActivityIntensity(invalidIntensity)).toThrowError(Errors.ActivityIntensityError());
-    });
-    const validActivitySettings1 = generateDefaultActivitySettings();
-    const validActivitySettings2 = {
-        ...validActivitySettings1,
-        hard: { fromZero: 1, fromThirty: 0.99, fromFortysix: null },
-    };
-    const validActivitySettings3 = {
-        ...validActivitySettings1,
-        hard: { fromZero: 0, fromThirty: 0, fromFortysix: 0 },
-    };
-    const invalidActivitySettings1 = {
-        ...validActivitySettings1,
-        // @ts-ignore Purposefully invalid settings
-        hard: { fromZero: 0, fromThirty: null, fromFortysix: null },
-    };
-    const invalidActivitySettings2 = {
-        ...validActivitySettings1,
-        // @ts-ignore Purposefully invalid settings
-        light: { fromZero: undefined, fromThirty: 0.99, fromFortysix: 0.25 },
-    };
-    const invalidActivitySettings3 = {
-        ...validActivitySettings1,
-        hard: { fromZero: 1, fromThirty: 0.99, fromFortysix: 1.1 },
-    };
-    const validActivity1 = {
-        activityDate: new Date(Date.now() - Milliseconds.Hour * 5 - Milliseconds.Minute * 9.9),
-        activityDuration: 60,
-        activityIntensity: moderate,
-        activitySettings: validActivitySettings1,
-    };
-    const validActivity2 = {
-        ...validActivity1,
-        activityDate: new Date(Date.now() - Milliseconds.Hour * 4.5 - Milliseconds.Minute * 9.9),
-        activityDuration: 30,
-    };
-    const invalidActivity1 = {
-        ...validActivity1,
-        activityDate: new Date(Date.now() - Milliseconds.Hour * 4.5 - Milliseconds.Minute * 10),
-        activityDuration: 30,
-    };
-    const invalidActivity2 = {
-        ...validActivity1,
-        activityDate: new Date(Date.now() - Milliseconds.Hour * 4.25 - Milliseconds.Minute * 10),
-        activityDuration: 15,
-    };
-    test(`Can call checkActivity with a valid activity`, () => {
-        expect(() => Validations.checkActivity(validActivity1)).not.toThrow();
-    });
-    test(`Can call checkActivity with an invalid activity and throw error`, () => {
-        expect(() => Validations.checkActivity(invalidActivity1)).toThrow();
-    });
-    test.each `
-		validActivity
-		${validActivity1}
-		${validActivity2}
-	`(`Validation checking on activity date $validActivity.activityDate`, ({ validActivity }) => {
-        expect(() => Validations.checkActivityDate(validActivity)).not.toThrowError(Errors.ActivityDateError());
-    });
-    test.each `
-		invalidActivity
-		${invalidActivity1}
-		${invalidActivity2}
-	`(`Validation checking on invalid activity $invalidActivity.activityDate throws error`, ({ invalidActivity }) => {
-        expect(() => Validations.checkActivityDate(invalidActivity)).toThrowError(Errors.ActivityDateError());
-    });
-    test.each `
-		validActivitySettings
-		${validActivitySettings1}
-		${validActivitySettings2}
-		${validActivitySettings3}
-	`(`Validation checking on validActivitySettings`, ({ validActivitySettings }) => {
-        expect(() => Validations.checkActivitySettings(validActivitySettings)).not.toThrowError(Errors.ActivitySettingsError());
-    });
-    test.each `
-		invalidActivitySettings
-		${invalidActivitySettings1}
-		${invalidActivitySettings2}
-		${invalidActivitySettings3}
-	`(`Validation checking on invalidActivitySettings throws error`, ({ invalidActivitySettings }) => {
-        expect(() => Validations.checkActivitySettings(invalidActivitySettings)).toThrowError(Errors.ActivitySettingsError());
-    });
-    test.each `
-		validActivityTargetBGL
-		${5}
-		${13.9}
-		${8}
-		${10}
-	`(`Validation checking on $validActivityTargetBGL `, ({ validActivityTargetBGL }) => {
-        expect(() => Validations.checkActivityTargetBGL(validActivityTargetBGL)).not.toThrowError(Errors.ActivityTargetBGLError());
-    });
-    test.each `
-		invalidActivityTargetBGL
-		${4.99}
-		${null}
-		${undefined}
-		${13.91}
-	`(`Validation checking on $invalidActivityTargetBGL throws error`, ({ invalidActivityTargetBGL }) => {
-        expect(() => Validations.checkActivityTargetBGL(invalidActivityTargetBGL)).toThrowError(Errors.ActivityTargetBGLError());
-    });
-    test.each `
-		validTargetBGL
-		${5}
-		${13.9}
-		${8}
-		${10}
-	`(`Validation checking on $validTargetBGL `, ({ validTargetBGL }) => {
-        expect(() => Validations.checkTargetBGL(validTargetBGL)).not.toThrowError(Errors.TargetBGLError());
-    });
-    test.each `
-		invalidTargetBGL
-		${4.99}
-		${null}
-		${undefined}
-		${13.91}
-	`(`Validation checking on $invalidTargetBGL throws error `, ({ invalidTargetBGL }) => {
-        expect(() => Validations.checkTargetBGL(invalidTargetBGL)).toThrowError(Errors.TargetBGLError());
-    });
-    test.each `
-		validCarbohydrates
-		${0}
-		${100}
-		${300}
-		${10}
-	`(`Validation checking on provided $validCarbohydrates `, ({ validCarbohydrates }) => {
-        expect(() => Validations.checkCarbohydrates(validCarbohydrates)).not.toThrowError(Errors.CarbohydrateLimitError());
-    });
-    test.each `
-		invalidCarbohydrates
-		${-2}
-		${null}
-		${undefined}
-		${301}
-	`(`Validation checking on provided $invalidCarbohydrates throws error`, ({ invalidCarbohydrates }) => {
-        expect(() => Validations.checkCarbohydrates(invalidCarbohydrates)).toThrowError(Errors.CarbohydrateLimitError());
-    });
-    test.each `
-		validCurrentBGL
-		${1.1}
-		${33.3}
-		${null}
-		${10}
-	`(`Validation checking on $validCurrentBGL `, ({ validCurrentBGL }) => {
-        expect(() => Validations.checkCurrentBGL(validCurrentBGL)).not.toThrowError(Errors.CurrentBGLError());
-    });
-    test.each `
-		invalidCurrentBGL
-		${1}
-		${33.31}
-		${undefined}
-		${0}
-	`(`Validation checking on $invalidCurrentBGL throws error`, ({ invalidCurrentBGL }) => {
-        expect(() => Validations.checkCurrentBGL(invalidCurrentBGL)).toThrowError(Errors.CurrentBGLError());
-    });
-    test.each `
-		validRatio
-		${1}
-		${50}
-		${25}
-		${49.99}
-	`(`Validation checking on IC $validRatio `, ({ validRatio }) => {
-        expect(() => Validations.checkInsulinToCarbRatio(validRatio)).not.toThrowError(Errors.InsulinToCarbsRatioError());
-    });
-    test.each `
-		invalidRatio
-		${0}
-		${null}
-		${undefined}
-		${51}
-	`(`Validation checking on IC $invalidRatio throws error`, ({ invalidRatio }) => {
-        expect(() => Validations.checkInsulinToCarbRatio(invalidRatio)).toThrowError(Errors.InsulinToCarbsRatioError());
-    });
-    test.each `
-		validInsulinSensitivity
-		${0.3}
-		${10}
-		${5}
-		${4.44}
-	`(`Validation checking on $validInsulinSensitivity `, ({ validInsulinSensitivity }) => {
-        expect(() => Validations.checkInsulinSensitivity(validInsulinSensitivity)).not.toThrowError(Errors.InsulinSensitivityError());
-    });
-    test.each `
-		invalidInsulinSensitivity
-		${0}
-		${null}
-		${undefined}
-		${10.01}
-	`(`Validation checking on $invalidInsulinSensitivity throws error`, (invalidInsulinSensitivity) => {
-        expect(() => Validations.checkInsulinSensitivity(invalidInsulinSensitivity)).toThrowError(Errors.InsulinSensitivityError());
-    });
-    const validBolus1 = {
-        insulinDose: 0,
-        secondsPassed: 1,
-    };
-    const validBolus2 = {
-        insulinDose: 50,
-        secondsPassed: FOUR_HOURS_SECONDS,
-    };
-    const invalidBolus1 = {
-        // @ts-ignore Forcefully incorrect.
-        insulinDose: null,
-        // @ts-ignore Forcefully incorrect.
-        secondsPassed: null,
-    };
-    const invalidBolus2 = {
-        // @ts-ignore Forcefully incorrect.
-        insulinDose: undefined,
-        secondsPassed: FOUR_HOURS_SECONDS + 1,
-    };
-    const invalidBolus3 = {
-        insulinDose: BolusCalculator.Constants.SAFETY_INSULIN_LIMIT + 1,
-        secondsPassed: -1,
-    };
-    test.each `
-		validRecentBoluses
-		${[validBolus1, validBolus2]}
-		${[validBolus2]}
-		${[]}
-	`(`Validation checking on Recent Boluses - insulin dose`, ({ validRecentBoluses }) => {
-        expect(() => Validations.checkRecentBolusesInsulinDose(validRecentBoluses)).not.toThrow();
-    });
-    test.each `
-		invalidRecentBoluses
-		${[validBolus1, invalidBolus1]}
-		${[invalidBolus2]}
-		${[validBolus2, invalidBolus3]}
-	`(`Validation checking on Recent Boluses insulin - dose throws error`, ({ invalidRecentBoluses }) => {
-        expect(() => Validations.checkRecentBolusesInsulinDose(invalidRecentBoluses)).toThrowError(Errors.BolusInsulinDoseError());
-    });
-    test.each `
-		validRecentBoluses
-		${[validBolus1, validBolus2]}
-		${[validBolus2]}
-		${[]}
-	`(`Validation checking on Recent Boluses seconds passed`, ({ validRecentBoluses }) => {
-        expect(() => Validations.checkRecentBolusesSecondsPassed(validRecentBoluses)).not.toThrowError(Errors.BolusInsulinSecondsPassedError());
-    });
-    test.each `
-		invalidRecentBoluses
-		${[validBolus1, invalidBolus1]}
-		${[validBolus2, invalidBolus2]}
-		${[validBolus2, invalidBolus3]}
-	`(`Validation checking on Recent Boluses seconds passed throws error`, ({ invalidRecentBoluses }) => {
-        expect(() => Validations.checkRecentBolusesSecondsPassed(invalidRecentBoluses)).toThrowError(Errors.BolusInsulinSecondsPassedError());
-    });
-    test.each `
-		invalidRecentBoluses
-		${null}
-		${undefined}
-	`(`Validation checking on Recent Boluses: null and undefined throws error`, ({ invalidRecentBoluses }) => {
-        expect(() => Validations.checkRecentBolus(invalidRecentBoluses)).toThrowError(Errors.RecentBolusError());
-    });
-    test.each `
-		validCurrentBKL
-		${0}
-		${8}
-		${null}
-		${5}
-	`(`Validation checking on $validCurrentBKL `, ({ validCurrentBKL }) => {
-        expect(() => Validations.checkBloodKetoneLevel(validCurrentBKL)).not.toThrowError(Errors.CurrentBKLError());
-    });
-    test.each `
-		invalidCurrentBKL
-		${-0.1}
-		${8.01}
-		${undefined}
-		${NaN}
-	`(`Validation checking on $invalidCurrentBKL throws error`, ({ invalidCurrentBKL }) => {
-        expect(() => Validations.checkBloodKetoneLevel(invalidCurrentBKL)).toThrowError(Errors.CurrentBKLError());
-    });
-});

package/src/__tests__/components/Activity.test.d.ts

@@ -1 +0,0 @@
-export {};

package/src/__tests__/components/Activity.test.js

@@ -1,86 +0,0 @@
-import { Activity, Languages } from "@hedia/types";
-import { I18nProvider } from "@lingui/react";
-import React from "react";
-import { cleanup, render } from "react-native-testing-library";
-import { default as ActivityComponent } from "../../components/activity/Activity";
-import { i18n } from "../../locale/i18nUtils";
-import { Testing } from "../../types/enum";
-import { ActivityIntensityTranslations } from "../../utils/Translations";
-import { expectTextExists, generateActivityProps, getRecommendationProps, i18nProvided, queryTextFromComponent, } from "../utils";
-const ActivityIntensity = Activity.Enums.ActivityIntensity;
-const { light, moderate, hard } = ActivityIntensity;
-describe(`Activity - Component`, () => {
-    afterEach(cleanup);
-    beforeEach(() => {
-        i18n.activate(Languages.en);
-    });
-    test.each `
-		activityIntensity
-		${light}
-		${moderate}
-		${hard}
-	`(`Renders $activityIntensity`, ({ activityIntensity }) => {
-        const { activityDisplayProps } = getRecommendationProps();
-        const activity = generateActivityProps();
-        const wrapper = render(i18nProvided(<ActivityComponent activity={{ ...activity, activityIntensity }} activityType={activityDisplayProps?.activityType ?? null} activityTitle={activityDisplayProps?.activityTitle ?? null} activityReduction={0}/>));
-        expectTextExists(wrapper, `Activity`);
-        expectTextExists(wrapper, `30`);
-        expectTextExists(wrapper, `min`);
-        expectTextExists(wrapper, `Based on the selected activity your insulin recommendation is reduced by:`);
-        expectTextExists(wrapper, ActivityIntensityTranslations[activityIntensity]());
-    });
-    test.each `
-		reduction
-		${0}
-		${0.25}
-		${0.33}
-		${0.5}
-		${0.8}
-	`(`Renders activity reduction from decimal: $reduction to percentage`, ({ reduction }) => {
-        const { activityDisplayProps } = getRecommendationProps();
-        const activity = generateActivityProps();
-        const wrapper = render(i18nProvided(<ActivityComponent activity={activity} activityType={activityDisplayProps?.activityType ?? null} activityReduction={reduction} activityTitle={activityDisplayProps?.activityTitle ?? null}/>));
-        expectTextExists(wrapper, `${reduction * 100}%`);
-    });
-    test(`Renders activity reduction as 0 when null is passed`, () => {
-        const { activityDisplayProps } = getRecommendationProps();
-        const activity = generateActivityProps();
-        const reduction = null;
-        const wrapper = render(i18nProvided(<ActivityComponent activity={activity} activityType={activityDisplayProps?.activityType ?? null} activityReduction={reduction} activityTitle={activityDisplayProps?.activityTitle ?? null}/>));
-        const text = queryTextFromComponent(wrapper, Testing.Id.ActivityTestIds.ActivityReduction);
-        expect(text).toBe(`0%`);
-    });
-    test(`Can render activity title`, () => {
-        const { activityDisplayProps } = getRecommendationProps();
-        const activity = generateActivityProps();
-        const wrapper = render(i18nProvided(<ActivityComponent activity={{ ...activity }} activityType={activityDisplayProps?.activityType ?? null} activityTitle={activityDisplayProps?.activityTitle ?? null} activityReduction={0}/>));
-        expectTextExists(wrapper, activityDisplayProps?.activityTitle);
-    });
-    test.each `
-		language     | locale          | message
-		${`English`} | ${Languages.en} | ${`Activity`}
-		${`Danish`}  | ${Languages.da} | ${`Aktivitet`}
-		${`German`}  | ${Languages.de} | ${`Aktivität`}
-		${`Spanish`} | ${Languages.es} | ${`Actividad`}
-		${`Italian`} | ${Languages.it} | ${`Attività fisica`}
-		${`French`}  | ${Languages.fr} | ${`Activité`}
-	`(`Can render in $language`, ({ message, locale }) => {
-        const { activityDisplayProps } = getRecommendationProps();
-        const activity = generateActivityProps();
-        i18n.activate(locale);
-        const wrapper = render(<I18nProvider language={locale} i18n={i18n}>
-				<ActivityComponent activity={activity} activityType={activityDisplayProps?.activityType ?? null} activityTitle={activityDisplayProps?.activityTitle ?? null} activityReduction={0}/>
-			</I18nProvider>);
-        expectTextExists(wrapper, message);
-    });
-    test(`ActivityIcon defaults to other if activityType is null`, () => {
-        const { activityDisplayProps } = getRecommendationProps();
-        const activity = generateActivityProps();
-        const wrapper = render(i18nProvided(<ActivityComponent activity={{ ...activity }} activityType={null} activityTitle={activityDisplayProps?.activityTitle ?? null} activityReduction={0}/>));
-        expectTextExists(wrapper, activityDisplayProps?.activityTitle);
-        const existingLabel = `${Activity.Enums.ActivityEnum[Activity.Enums.ActivityEnum.Other]}_activity`;
-        const nonExistingLabel = `${Activity.Enums.ActivityEnum[Activity.Enums.ActivityEnum.Run]}_activity`;
-        expect(wrapper.queryByA11yLabel(existingLabel)).not.toBeNull();
-        expect(wrapper.queryByA11yLabel(nonExistingLabel)).toBeNull();
-    });
-});

package/src/__tests__/components/Emotion.test.d.ts

@@ -1 +0,0 @@
-export {};

package/src/__tests__/components/Emotion.test.js

@@ -1,70 +0,0 @@
-import { Languages, Logbook } from "@hedia/types";
-import React from "react";
-import { cleanup, fireEvent, render } from "react-native-testing-library";
-import Emotion from "../../components/mood/Emotion";
-import { i18n } from "../../locale/i18nUtils";
-import { expectTextExists, getIcon, i18nProvided } from "../utils";
-const MoodEnum = Logbook.Enums.MoodEnum;
-describe(`Emotion - Component`, () => {
-    afterEach(cleanup);
-    beforeEach(() => {
-        i18n.activate(Languages.en);
-    });
-    test(`Can mount component in `, () => {
-        const mockSelected = jest.fn();
-        const wrapper = render(i18nProvided(<Emotion moodSelected={mockSelected} currentMood={null}/>));
-        expectTextExists(wrapper, `How are you feeling?`);
-    });
-    test.each `
-		mood                  | moodName                        | preselected           | preselectedName
-		${MoodEnum.Happy}     | ${MoodEnum[MoodEnum.Happy]}     | ${MoodEnum.Sad}       | ${MoodEnum[MoodEnum.Sad]}
-		${MoodEnum.SemiHappy} | ${MoodEnum[MoodEnum.SemiHappy]} | ${MoodEnum.Happy}     | ${MoodEnum[MoodEnum.Happy]}
-		${MoodEnum.Neutral}   | ${MoodEnum[MoodEnum.Neutral]}   | ${MoodEnum.SemiHappy} | ${MoodEnum[MoodEnum.SemiHappy]}
-		${MoodEnum.SemiSad}   | ${MoodEnum[MoodEnum.SemiSad]}   | ${MoodEnum.Neutral}   | ${MoodEnum[MoodEnum.Neutral]}
-		${MoodEnum.Sad}       | ${MoodEnum[MoodEnum.Sad]}       | ${MoodEnum.SemiSad}   | ${MoodEnum[MoodEnum.SemiSad]}
-	`(`Pressing on $moodName icon deselects others`, ({ mood, moodName, preselected, preselectedName, }) => {
-        let mockedStateMood = preselected;
-        const mockSelected = jest.fn((selectedMood) => (mockedStateMood = selectedMood));
-        const wrapper = render(<Emotion moodSelected={mockSelected} currentMood={mockedStateMood}/>);
-        const preIcon = getIcon(wrapper, preselectedName, true);
-        if (preIcon === null) {
-            return fail(`No icon found for queryByA11yLabel: ${preselectedName}_${true}`);
-        }
-        const newIcon = getIcon(wrapper, moodName, false);
-        if (newIcon === null) {
-            return fail(`No icon found for queryByA11yLabel: ${moodName}_${false}`);
-        }
-        // Select a different mood
-        fireEvent(newIcon, `onPress`);
-        expect(mockedStateMood).toBe(mood);
-        wrapper.update(<Emotion moodSelected={mockSelected} currentMood={mockedStateMood}/>);
-        const moodValues = Object.values(MoodEnum).filter((value) => typeof value === `string`);
-        moodValues.forEach((value) => {
-            if (moodName === value) {
-                expect(getIcon(wrapper, value, true)).not.toBeNull();
-                expect(getIcon(wrapper, value, false)).toBeNull();
-            }
-            else {
-                expect(getIcon(wrapper, value, false)).not.toBeNull();
-                expect(getIcon(wrapper, value, true)).toBeNull();
-            }
-        });
-    });
-    test(`Deselecting selected icon by pressing it again`, () => {
-        let mockedStateMood = MoodEnum.Happy;
-        const mockSelected = jest.fn((newMood) => (mockedStateMood = newMood));
-        const mood = MoodEnum[mockedStateMood];
-        const wrapper = render(<Emotion moodSelected={mockSelected} currentMood={mockedStateMood}/>);
-        // current mood has already been selected: Happy
-        expect(getIcon(wrapper, mood, true)).not.toBeNull();
-        expect(getIcon(wrapper, mood, false)).toBeNull();
-        const icon = getIcon(wrapper, mood, true);
-        if (icon === null) {
-            return fail(`No icon found for queryByA11yLabel: ${mood}_${true}`);
-        }
-        fireEvent(icon, `onPress`);
-        wrapper.update(<Emotion moodSelected={mockSelected} currentMood={mockedStateMood}/>);
-        expect(getIcon(wrapper, mood, true)).toBeNull();
-        expect(getIcon(wrapper, mood, false)).not.toBeNull();
-    });
-});

package/src/__tests__/components/Header.test.d.ts

@@ -1 +0,0 @@
-export {};

package/src/__tests__/components/Header.test.js

@@ -1,36 +0,0 @@
-import React from "react";
-import { cleanup, fireEvent, render } from "react-native-testing-library";
-import { expectTextExists, getRecommendationProps } from "../utils";
-import { I18nProvider } from "@lingui/react";
-import Header from "../../components/Header";
-import { Languages } from "@hedia/types";
-import { i18n } from "../../locale/i18nUtils";
-import { Testing } from "../../types/enum";
-describe(`Header Component`, () => {
-    afterEach(cleanup);
-    test(`Exit button calls exitCallback`, () => {
-        const props = getRecommendationProps();
-        const { getByTestId } = render(<Header exitCallback={props.exitCallback}/>);
-        expect(props.exitCallback).not.toBeCalled();
-        fireEvent.press(getByTestId(Testing.Id.HeaderTestIds.ExitCalculation));
-        expect(props.exitCallback).toBeCalled();
-    });
-    test.each `
-		language     | locale          | header
-		${`English`} | ${Languages.en} | ${`INSULIN\nRECOMMENDATION`}
-		${`Danish`}  | ${Languages.da} | ${`INSULIN\nANBEFALING`}
-		${`German`}  | ${Languages.de} | ${`INSULIN\nEMPFEHLUNG`}
-		${`Spanish`} | ${Languages.es} | ${`RECOMENDACIÓN\nDE INSULINA`}
-		${`Italian`} | ${Languages.it} | ${`PRESCRIZIONE DI\nINSULINA`}
-		${`French`}  | ${Languages.fr} | ${`RECOMMANDATION\nD’INSULINE`}
-	`(`Header is translated to $language`, ({ header, locale }) => {
-        const props = getRecommendationProps({
-            language: locale,
-        });
-        i18n.activate(locale);
-        const wrapper = render(<I18nProvider language={locale} i18n={i18n}>
-				<Header exitCallback={props.exitCallback}/>
-			</I18nProvider>);
-        expectTextExists(wrapper, header);
-    });
-});

package/src/__tests__/components/InfoBars.test.d.ts

@@ -1 +0,0 @@
-export {};