@doctocar/tooling 0.3.1-33 → 0.3.1-35

package/dist/firebase/firestore/utils/dataValidators/slots/__tests__/isValidRecurringSlot.test.js

@@ -0,0 +1,527 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const enums_1 = require("../../../../../../enums");
+const constants_1 = require("../../../../constants");
+const enums_2 = require("../../../../enums");
+const stubs_1 = require("../../../stubs");
+const isValidRecurringSlot_1 = require("../isValidRecurringSlot");
+describe("isValidRecurringSlot", () => {
+    const baseValidSlot = {
+        type: enums_2.SlotType.RECURRING,
+        capacity: 3,
+        startDate: (0, stubs_1.firestoreTimestampStub)(),
+        endDate: null,
+        daysOfWeek: [enums_1.WeekDays.MONDAY, enums_1.WeekDays.WEDNESDAY],
+        intervalWeeks: 1,
+        timeZone: "Europe/Paris",
+        createdAt: (0, stubs_1.firestoreTimestampStub)(),
+        updatedAt: (0, stubs_1.firestoreTimestampStub)(),
+    };
+    it("returns true for a valid slot", () => {
+        const slot = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(true);
+    });
+    it("return true for differents valid timezones", () => {
+        const validTimezones = [
+            "Europe/Paris",
+            "Europe/Berlin",
+            "Europe/Madrid",
+            "Europe/Rome",
+            "Europe/Brussels",
+            "Europe/Moscow",
+            "America/New_York",
+            "Asia/Tokyo",
+            "Australia/Sydney",
+            "UTC",
+            "Europe/London",
+            "America/Los_Angeles",
+            "Asia/Kolkata",
+            "America/Argentina/Buenos_Aires",
+            "Asia/Shanghai",
+        ];
+        validTimezones.forEach((timezone) => {
+            const slot = {
+                ...baseValidSlot,
+                timeZone: timezone,
+                localTimeRangeOfDay: {
+                    startTime: {
+                        hour: 9,
+                        minute: 0,
+                    },
+                    endTime: {
+                        hour: 10,
+                        minute: 30,
+                    },
+                },
+                intervalWeeks: 1,
+            };
+            expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(true);
+        });
+    });
+    it("return false if type is not RECURRING", () => {
+        const slot = {
+            ...baseValidSlot,
+            type: enums_2.SlotType.ONE_TIME,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+    });
+    it("return false if startAt or endAt is missing", () => {
+        const missingStart = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        const missingEnd = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(missingStart)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(missingEnd)).toBe(false);
+    });
+    it("return false if timeZone is missing or invalid", () => {
+        const missingTimeZone = {
+            ...baseValidSlot,
+            timeZone: undefined,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(missingTimeZone)).toBe(false);
+        const slot = {
+            ...baseValidSlot,
+            timeZone: "",
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+        const invalidSlot = {
+            ...baseValidSlot,
+            timeZone: "Invalid/Timezone",
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(invalidSlot)).toBe(false);
+    });
+    it("return false if startDate is missing", () => {
+        const slot = {
+            ...baseValidSlot,
+            startDate: undefined,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+    });
+    it("return false if startDate is not a valid timestamp", () => {
+        const slot = {
+            ...baseValidSlot,
+            startDate: { toMillis: () => NaN },
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+    });
+    it("return false if endDate is not a valid timestamp", () => {
+        const slot = {
+            ...baseValidSlot,
+            endDate: { toMillis: () => NaN },
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+    });
+    it("return false if capacity is not an integer ≥ 1 <= MAXIMUM_SLOT_CAPACITY", () => {
+        const zeroCap = {
+            ...baseValidSlot,
+            capacity: 0,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        const negCap = {
+            ...baseValidSlot,
+            capacity: -5,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        const floatCap = {
+            ...baseValidSlot,
+            capacity: 2.5,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        const tooBigCap = {
+            ...baseValidSlot,
+            capacity: constants_1.MAXIMUM_SLOT_CAPACITY + 1,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+            intervalWeeks: 1,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(zeroCap)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(negCap)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(floatCap)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(tooBigCap)).toBe(false);
+    });
+    it("return false if startAt ≥ endAt", () => {
+        const equalTimes = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        const backwards = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 8,
+                    minute: 30,
+                },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(equalTimes)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(backwards)).toBe(false);
+    });
+    it("return false if there is duplicate weekdays", () => {
+        const duplicateDays = {
+            ...baseValidSlot,
+            daysOfWeek: [enums_1.WeekDays.MONDAY, enums_1.WeekDays.MONDAY],
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(duplicateDays)).toBe(false);
+    });
+    it("return false if daysOfWeek contains invalid values", () => {
+        const invalidDays = {
+            ...baseValidSlot,
+            daysOfWeek: [enums_1.WeekDays.MONDAY, "INVALID_DAY"],
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(invalidDays)).toBe(false);
+    });
+    it("return false if startAt or endAt does not have hour or minute", () => {
+        const badStart = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: undefined, minute: 0 },
+                endTime: { hour: 10, minute: 30 },
+            },
+        };
+        const badEnd = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: undefined, minute: 30 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badStart)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badEnd)).toBe(false);
+    });
+    it("return false if startAt or endAt hour is not an integer in [0, 23]", () => {
+        const badStart = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: 24, minute: 0 },
+                endTime: { hour: 10, minute: 30 },
+            },
+        };
+        const badEnd = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: -1, minute: 30 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badStart)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badEnd)).toBe(false);
+    });
+    it("return false if startAt or endAt minute is not an integer in [0, 59]", () => {
+        const badStart = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 60 },
+                endTime: { hour: 10, minute: 30 },
+            },
+        };
+        const badEnd = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: 10, minute: -1 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badStart)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badEnd)).toBe(false);
+    });
+    it("return false if intervalWeeks is not an integer in [1, 52]", () => {
+        const badInterval = {
+            ...baseValidSlot,
+            intervalWeeks: 0,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        const badInterval2 = {
+            ...baseValidSlot,
+            intervalWeeks: 53,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        const badInterval3 = {
+            ...baseValidSlot,
+            intervalWeeks: -1.5,
+            localTimeRangeOfDay: {
+                startTime: {
+                    hour: 9,
+                    minute: 0,
+                },
+                endTime: {
+                    hour: 10,
+                    minute: 30,
+                },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badInterval)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badInterval2)).toBe(false);
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(badInterval3)).toBe(false);
+    });
+    it("return false if daysOfWeek is empty", () => {
+        const slot = {
+            ...baseValidSlot,
+            daysOfWeek: [],
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: 10, minute: 0 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+    });
+    it("allows a single weekday", () => {
+        const slot = {
+            ...baseValidSlot,
+            daysOfWeek: [enums_1.WeekDays.FRIDAY],
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: 10, minute: 0 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(true);
+    });
+    it("return false if intervalWeeks is missing", () => {
+        const slot = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: 10, minute: 0 },
+            },
+            intervalWeeks: undefined,
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+    });
+    it("allows intervalWeeks of 1 and 52", () => {
+        for (const n of [1, 52]) {
+            const slot = {
+                ...baseValidSlot,
+                localTimeRangeOfDay: {
+                    startTime: { hour: 9, minute: 0 },
+                    endTime: { hour: 10, minute: 0 },
+                },
+                intervalWeeks: n,
+            };
+            expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(true);
+        }
+    });
+    it("allows startAt 00:00 and endAt 23:59", () => {
+        const slot = {
+            ...baseValidSlot,
+            localTimeRangeOfDay: {
+                startTime: { hour: 0, minute: 0 },
+                endTime: { hour: 23, minute: 59 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(true);
+    });
+    it("allows capacity of exactly 1", () => {
+        const slot = {
+            ...baseValidSlot,
+            capacity: 1,
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: 10, minute: 0 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(true);
+    });
+    it("return false if capacity is missing", () => {
+        const slot = {
+            ...baseValidSlot,
+            capacity: undefined,
+            localTimeRangeOfDay: {
+                startTime: { hour: 9, minute: 0 },
+                endTime: { hour: 10, minute: 0 },
+            },
+        };
+        expect((0, isValidRecurringSlot_1.isValidRecurringSlot)(slot)).toBe(false);
+    });
+});

package/dist/firebase/firestore/utils/dataValidators/slots/__tests__/isValidTimeOffSlot.test.d.ts

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