@hedia/recommendation-screen 2.0.2 → 2.1.1

package/src/__tests__/Validations.test.ts

@@ -1,648 +0,0 @@
-import { Activity, BloodGlucoseUnit, BloodKetonesUnit, Languages, Milliseconds, UserSettings } from "@hedia/types";
-import { ActivitySettings, IActivityParams, IRecentBolus, logbookEntry } from "../types/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`, (): void => {
-	test.each`
-		validInjectionMethod
-		${InjectionMethod.PenHalf}
-		${InjectionMethod.PenWhole}
-		${InjectionMethod.Pump}
-	`(
-		`Validation checking on treatment types $validInjectionMethod `,
-		({ validInjectionMethod }: { validInjectionMethod: UserSettings.Enums.InjectionMethod }): void => {
-			expect((): void => Validations.checkInjectionMethod(validInjectionMethod)).not.toThrowError(
-				Errors.InjectionMethodError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidInjectionMethod
-		${`Pen`}
-		${`Injection`}
-		${`Hedia`}
-	`(
-		`Validation checking on treatment types $invalidInjectionMethod throws error`,
-		(invalidInjectionMethod: UserSettings.Enums.InjectionMethod): void => {
-			expect((): void => Validations.checkInjectionMethod(invalidInjectionMethod)).toThrowError(
-				Errors.InjectionMethodError(),
-			);
-		},
-	);
-
-	test.each`
-		validUnit
-		${BloodGlucoseUnit.MG_DL}
-		${BloodGlucoseUnit.MMOL_L}
-	`(
-		`Validation checking on blood glucose unit types $validUnit`,
-		({ validUnit }: { validUnit: BloodGlucoseUnit }): void => {
-			expect((): void => 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 }: { invalidUnit: BloodGlucoseUnit }): void => {
-			expect((): void => Validations.checkBGLUnit(invalidUnit)).toThrowError(Errors.BloodGlucoseUnitError());
-		},
-	);
-	test.each`
-		validUnit
-		${BloodKetonesUnit.MG_DL}
-		${BloodKetonesUnit.MMOL_L}
-	`(
-		`Validation checking on blood ketones unit types $validUnit`,
-		({ validUnit }: { validUnit: BloodKetonesUnit }): void => {
-			expect((): void => 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 }: { invalidUnit: BloodKetonesUnit }): void => {
-			expect((): void => 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 }: { validLanguage: Languages }): void => {
-			expect((): void => Validations.checkLanguage(validLanguage)).not.toThrowError(Errors.LanguageError());
-		},
-	);
-
-	test.each`
-		invalidLanguage
-		${`Polish`}
-		${`Danish`}
-		${`Dansk`}
-		${`Deutsch`}
-	`(
-		`Validation checking on supported languages types $invalidLanguage throws error`,
-		(invalidLanguage: Languages): void => {
-			expect((): void => Validations.checkLanguage(invalidLanguage)).toThrowError(Errors.LanguageError());
-		},
-	);
-
-	it.each`
-		validLatestLogbookFrom6Hours
-		${generateDefaultLogbook()}
-		${null}
-	`(
-		`Validation checking on the latest logbook from the latest 6 hours with a valid logbook`,
-		({ validLatestLogbookFrom6Hours }: { validLatestLogbookFrom6Hours: logbookEntry }): void => {
-			expect((): void => 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 }: { invalidLatestLogbookFrom6Hours: logbookEntry }): void => {
-			expect((): void => 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 }: { validActivityType: Activity.Enums.ActivityEnum }): void => {
-			expect((): void => Validations.checkActivityType(validActivityType)).not.toThrowError(
-				Errors.ActivityTypeError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidActivityType
-		${`Dance`}
-		${`Walking`}
-		${`Swimming`}
-		${`Running`}
-		${`Cycle`}
-	`(
-		`Validation checking on activity types $invalidActivityType throws error`,
-		(invalidActivityType: Activity.Enums.ActivityEnum): void => {
-			expect((): void => Validations.checkActivityType(invalidActivityType)).toThrowError(
-				Errors.ActivityTypeError(),
-			);
-		},
-	);
-
-	test.each`
-		validUserReminder
-		${0}
-		${6}
-		${3}
-		${4.5}
-	`(
-		`Validation checking on the user reminder value $validUserReminder`,
-		({ validUserReminder: validUserReminder }: { validUserReminder: number }): void => {
-			expect((): void => 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 }: { invalidUserReminder: number }): void => {
-			expect((): void => Validations.checkUserReminder(invalidUserReminder)).toThrowError(
-				Errors.UserReminderError(),
-			);
-		},
-	);
-});
-
-describe(`Test validations for the calculator parameters`, (): void => {
-	test.each`
-		validDuration
-		${1}
-		${60}
-		${34}
-		${5.555}
-	`(`Validation checking on activity $validDuration `, ({ validDuration }: { validDuration: number }): void => {
-		expect((): void => Validations.checkActivityDuration(validDuration)).not.toThrowError(
-			Errors.ActivityDurationError(),
-		);
-	});
-
-	test.each`
-		invalidDuration
-		${0}
-		${61}
-		${undefined}
-		${null}
-	`(`Validation checking on activity $invalidDuration throws error`, (invalidDuration: number): void => {
-		expect((): void => Validations.checkActivityDuration(invalidDuration)).toThrowError(
-			Errors.ActivityDurationError(),
-		);
-	});
-
-	test.each`
-		validIntensity
-		${hard}
-		${light}
-		${moderate}
-	`(
-		`Validation checking on activity $validIntensity`,
-		({ validIntensity }: { validIntensity: Activity.Enums.ActivityIntensity }): void => {
-			expect((): void => Validations.checkActivityIntensity(validIntensity)).not.toThrowError(
-				Errors.ActivityIntensityError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidIntensity
-		${`Hard`}
-		${`easy`}
-		${undefined}
-		${null}
-	`(
-		`Validation checking on activity $invalidIntensity throws error`,
-		({ invalidIntensity }: { invalidIntensity: Activity.Enums.ActivityIntensity }): void => {
-			expect((): void => Validations.checkActivityIntensity(invalidIntensity)).toThrowError(
-				Errors.ActivityIntensityError(),
-			);
-		},
-	);
-
-	const validActivitySettings1: ActivitySettings = generateDefaultActivitySettings();
-
-	const validActivitySettings2: ActivitySettings = {
-		...validActivitySettings1,
-		hard: { fromZero: 1, fromThirty: 0.99, fromFortysix: null },
-	};
-
-	const validActivitySettings3: ActivitySettings = {
-		...validActivitySettings1,
-		hard: { fromZero: 0, fromThirty: 0, fromFortysix: 0 },
-	};
-
-	const invalidActivitySettings1: ActivitySettings = {
-		...validActivitySettings1,
-		// @ts-ignore Purposefully invalid settings
-		hard: { fromZero: 0, fromThirty: null, fromFortysix: null },
-	};
-
-	const invalidActivitySettings2: ActivitySettings = {
-		...validActivitySettings1,
-		// @ts-ignore Purposefully invalid settings
-		light: { fromZero: undefined, fromThirty: 0.99, fromFortysix: 0.25 },
-	};
-
-	const invalidActivitySettings3: ActivitySettings = {
-		...validActivitySettings1,
-		hard: { fromZero: 1, fromThirty: 0.99, fromFortysix: 1.1 },
-	};
-
-	const validActivity1: IActivityParams = {
-		activityDate: new Date(Date.now() - Milliseconds.Hour * 5 - Milliseconds.Minute * 9.9),
-		activityDuration: 60,
-		activityIntensity: moderate,
-		activitySettings: validActivitySettings1,
-	};
-
-	const validActivity2: IActivityParams = {
-		...validActivity1,
-		activityDate: new Date(Date.now() - Milliseconds.Hour * 4.5 - Milliseconds.Minute * 9.9),
-		activityDuration: 30,
-	};
-
-	const invalidActivity1: IActivityParams = {
-		...validActivity1,
-		activityDate: new Date(Date.now() - Milliseconds.Hour * 4.5 - Milliseconds.Minute * 10),
-		activityDuration: 30,
-	};
-
-	const invalidActivity2: IActivityParams = {
-		...validActivity1,
-		activityDate: new Date(Date.now() - Milliseconds.Hour * 4.25 - Milliseconds.Minute * 10),
-		activityDuration: 15,
-	};
-
-	test(`Can call checkActivity with a valid activity`, (): void => {
-		expect((): void => Validations.checkActivity(validActivity1)).not.toThrow();
-	});
-
-	test(`Can call checkActivity with an invalid activity and throw error`, (): void => {
-		expect((): void => Validations.checkActivity(invalidActivity1)).toThrow();
-	});
-
-	test.each`
-		validActivity
-		${validActivity1}
-		${validActivity2}
-	`(
-		`Validation checking on activity date $validActivity.activityDate`,
-		({ validActivity }: { validActivity: IActivityParams }): void => {
-			expect((): void => Validations.checkActivityDate(validActivity)).not.toThrowError(
-				Errors.ActivityDateError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidActivity
-		${invalidActivity1}
-		${invalidActivity2}
-	`(
-		`Validation checking on invalid activity $invalidActivity.activityDate throws error`,
-		({ invalidActivity }: { invalidActivity: IActivityParams }): void => {
-			expect((): void => Validations.checkActivityDate(invalidActivity)).toThrowError(Errors.ActivityDateError());
-		},
-	);
-
-	test.each`
-		validActivitySettings
-		${validActivitySettings1}
-		${validActivitySettings2}
-		${validActivitySettings3}
-	`(
-		`Validation checking on validActivitySettings`,
-		({ validActivitySettings }: { validActivitySettings: ActivitySettings }): void => {
-			expect((): void => Validations.checkActivitySettings(validActivitySettings)).not.toThrowError(
-				Errors.ActivitySettingsError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidActivitySettings
-		${invalidActivitySettings1}
-		${invalidActivitySettings2}
-		${invalidActivitySettings3}
-	`(
-		`Validation checking on invalidActivitySettings throws error`,
-		({ invalidActivitySettings }: { invalidActivitySettings: ActivitySettings }): void => {
-			expect((): void => Validations.checkActivitySettings(invalidActivitySettings)).toThrowError(
-				Errors.ActivitySettingsError(),
-			);
-		},
-	);
-
-	test.each`
-		validActivityTargetBGL
-		${5}
-		${13.9}
-		${8}
-		${10}
-	`(
-		`Validation checking on $validActivityTargetBGL `,
-		({ validActivityTargetBGL }: { validActivityTargetBGL: number }): void => {
-			expect((): void => Validations.checkActivityTargetBGL(validActivityTargetBGL)).not.toThrowError(
-				Errors.ActivityTargetBGLError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidActivityTargetBGL
-		${4.99}
-		${null}
-		${undefined}
-		${13.91}
-	`(
-		`Validation checking on $invalidActivityTargetBGL throws error`,
-		({ invalidActivityTargetBGL }: { invalidActivityTargetBGL: number }): void => {
-			expect((): void => Validations.checkActivityTargetBGL(invalidActivityTargetBGL)).toThrowError(
-				Errors.ActivityTargetBGLError(),
-			);
-		},
-	);
-
-	test.each`
-		validTargetBGL
-		${5}
-		${13.9}
-		${8}
-		${10}
-	`(`Validation checking on $validTargetBGL `, ({ validTargetBGL }: { validTargetBGL: number }): void => {
-		expect((): void => Validations.checkTargetBGL(validTargetBGL)).not.toThrowError(Errors.TargetBGLError());
-	});
-
-	test.each`
-		invalidTargetBGL
-		${4.99}
-		${null}
-		${undefined}
-		${13.91}
-	`(
-		`Validation checking on $invalidTargetBGL throws error `,
-		({ invalidTargetBGL }: { invalidTargetBGL: number }): void => {
-			expect((): void => Validations.checkTargetBGL(invalidTargetBGL)).toThrowError(Errors.TargetBGLError());
-		},
-	);
-
-	test.each`
-		validCarbohydrates
-		${0}
-		${100}
-		${300}
-		${10}
-	`(
-		`Validation checking on provided $validCarbohydrates `,
-		({ validCarbohydrates }: { validCarbohydrates: number }): void => {
-			expect((): void => Validations.checkCarbohydrates(validCarbohydrates)).not.toThrowError(
-				Errors.CarbohydrateLimitError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidCarbohydrates
-		${-2}
-		${null}
-		${undefined}
-		${301}
-	`(
-		`Validation checking on provided $invalidCarbohydrates throws error`,
-		({ invalidCarbohydrates }: { invalidCarbohydrates: number }): void => {
-			expect((): void => Validations.checkCarbohydrates(invalidCarbohydrates)).toThrowError(
-				Errors.CarbohydrateLimitError(),
-			);
-		},
-	);
-
-	test.each`
-		validCurrentBGL
-		${1.1}
-		${33.3}
-		${null}
-		${10}
-	`(`Validation checking on $validCurrentBGL `, ({ validCurrentBGL }: { validCurrentBGL: number }): void => {
-		expect((): void => Validations.checkCurrentBGL(validCurrentBGL)).not.toThrowError(Errors.CurrentBGLError());
-	});
-
-	test.each`
-		invalidCurrentBGL
-		${1}
-		${33.31}
-		${undefined}
-		${0}
-	`(
-		`Validation checking on $invalidCurrentBGL throws error`,
-		({ invalidCurrentBGL }: { invalidCurrentBGL: number }): void => {
-			expect((): void => Validations.checkCurrentBGL(invalidCurrentBGL)).toThrowError(Errors.CurrentBGLError());
-		},
-	);
-
-	test.each`
-		validRatio
-		${1}
-		${50}
-		${25}
-		${49.99}
-	`(`Validation checking on IC $validRatio `, ({ validRatio }: { validRatio: number }): void => {
-		expect((): void => Validations.checkInsulinToCarbRatio(validRatio)).not.toThrowError(
-			Errors.InsulinToCarbsRatioError(),
-		);
-	});
-
-	test.each`
-		invalidRatio
-		${0}
-		${null}
-		${undefined}
-		${51}
-	`(`Validation checking on IC $invalidRatio throws error`, ({ invalidRatio }: { invalidRatio: number }): void => {
-		expect((): void => Validations.checkInsulinToCarbRatio(invalidRatio)).toThrowError(
-			Errors.InsulinToCarbsRatioError(),
-		);
-	});
-
-	test.each`
-		validInsulinSensitivity
-		${0.3}
-		${10}
-		${5}
-		${4.44}
-	`(
-		`Validation checking on $validInsulinSensitivity `,
-		({ validInsulinSensitivity }: { validInsulinSensitivity: number }): void => {
-			expect((): void => Validations.checkInsulinSensitivity(validInsulinSensitivity)).not.toThrowError(
-				Errors.InsulinSensitivityError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidInsulinSensitivity
-		${0}
-		${null}
-		${undefined}
-		${10.01}
-	`(`Validation checking on $invalidInsulinSensitivity throws error`, (invalidInsulinSensitivity: number): void => {
-		expect((): void => Validations.checkInsulinSensitivity(invalidInsulinSensitivity)).toThrowError(
-			Errors.InsulinSensitivityError(),
-		);
-	});
-
-	const validBolus1: IRecentBolus = {
-		insulinDose: 0,
-		secondsPassed: 1,
-	};
-	const validBolus2: IRecentBolus = {
-		insulinDose: 50,
-		secondsPassed: FOUR_HOURS_SECONDS,
-	};
-	const invalidBolus1: IRecentBolus = {
-		// @ts-ignore Forcefully incorrect.
-		insulinDose: null,
-		// @ts-ignore Forcefully incorrect.
-		secondsPassed: null,
-	};
-	const invalidBolus2: IRecentBolus = {
-		// @ts-ignore Forcefully incorrect.
-		insulinDose: undefined,
-		secondsPassed: FOUR_HOURS_SECONDS + 1,
-	};
-	const invalidBolus3: IRecentBolus = {
-		insulinDose: 51,
-		secondsPassed: -1,
-	};
-
-	test.each`
-		validRecentBoluses
-		${[validBolus1, validBolus2]}
-		${[validBolus2]}
-		${[]}
-	`(
-		`Validation checking on Recent Boluses - insulin dose`,
-		({ validRecentBoluses }: { validRecentBoluses: Array<IRecentBolus> }): void => {
-			expect((): void => Validations.checkRecentBolusesInsulinDose(validRecentBoluses)).not.toThrow();
-		},
-	);
-
-	test.each`
-		invalidRecentBoluses
-		${[validBolus1, invalidBolus1]}
-		${[invalidBolus2]}
-		${[validBolus2, invalidBolus3]}
-	`(
-		`Validation checking on Recent Boluses insulin - dose throws error`,
-		({ invalidRecentBoluses }: { invalidRecentBoluses: Array<IRecentBolus> }): void => {
-			expect((): void => Validations.checkRecentBolusesInsulinDose(invalidRecentBoluses)).toThrowError(
-				Errors.BolusInsulinDoseError(),
-			);
-		},
-	);
-
-	test.each`
-		validRecentBoluses
-		${[validBolus1, validBolus2]}
-		${[validBolus2]}
-		${[]}
-	`(
-		`Validation checking on Recent Boluses seconds passed`,
-		({ validRecentBoluses }: { validRecentBoluses: Array<IRecentBolus> }): void => {
-			expect((): void => 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 }: { invalidRecentBoluses: Array<IRecentBolus> }): void => {
-			expect((): void => Validations.checkRecentBolusesSecondsPassed(invalidRecentBoluses)).toThrowError(
-				Errors.BolusInsulinSecondsPassedError(),
-			);
-		},
-	);
-
-	test.each`
-		invalidRecentBoluses
-		${null}
-		${undefined}
-	`(
-		`Validation checking on Recent Boluses: null and undefined throws error`,
-		({ invalidRecentBoluses }: { invalidRecentBoluses: Array<IRecentBolus> }): void => {
-			expect((): void => Validations.checkRecentBolus(invalidRecentBoluses)).toThrowError(
-				Errors.RecentBolusError(),
-			);
-		},
-	);
-
-	test.each`
-		validCurrentBKL
-		${0}
-		${8}
-		${null}
-		${5}
-	`(`Validation checking on $validCurrentBKL `, ({ validCurrentBKL }: { validCurrentBKL: number }): void => {
-		expect((): void => Validations.checkBloodKetoneLevel(validCurrentBKL)).not.toThrowError(
-			Errors.CurrentBKLError(),
-		);
-	});
-
-	test.each`
-		invalidCurrentBKL
-		${-0.1}
-		${8.01}
-		${undefined}
-		${NaN}
-	`(
-		`Validation checking on $invalidCurrentBKL throws error`,
-		({ invalidCurrentBKL }: { invalidCurrentBKL: number }): void => {
-			expect((): void => Validations.checkBloodKetoneLevel(invalidCurrentBKL)).toThrowError(
-				Errors.CurrentBKLError(),
-			);
-		},
-	);
-});