cronofy-elements 1.48.2 → 1.49.2

package/tests/DateTimePicker/contexts/status-reducer.test.js

@@ -1,1036 +0,0 @@
-import { statusReducer } from "../../../src/js/components/DateTimePicker/contexts/status-reducer";
-import {
-    testSingleSlotsArray,
-    testSingleSlotsObject,
-    testSlotsObject,
-    testSlotsObjectPartial,
-    testSlotsArray,
-    testSlotsArrayAdditional,
-    testSequencedSlotsArray,
-    testDaySlots,
-    testDaySequencedSlots,
-    testSequencedSlotsObject,
-    testQuery,
-    testSequencedQuery,
-} from "../dummy-data";
-
-import {
-    getAvailableDays,
-    getMonthObjectsFromQuery,
-    getMonthsLoadingFromQuery,
-} from "../../../src/js/components/DateTimePicker/utils/slots";
-import {
-    getMonthsInDisplay,
-    parseTimeSlots,
-} from "../../../src/js/components/DateTimePicker/utils/calendar";
-import moment from "moment";
-
-const months = getMonthObjectsFromQuery(testQuery, "Europe/London");
-const monthsLoading = getMonthsLoadingFromQuery(testQuery, "Europe/London");
-
-const testMonthlySlots = months.map((month, i) => ({
-    month: month.month,
-    hasNext: i < months.length - 1 ? true : false,
-    hasPrev: i > 0 ? true : false,
-    monthsInView: getMonthsInDisplay(month.month, "sunday"),
-    days: parseTimeSlots({
-        slots: testSlotsObject,
-        month: month.month,
-        tzid: "Europe/London",
-        startDay: "sunday",
-    }),
-}));
-
-const testMonthlyView = testMonthlySlots[0];
-
-const startingState = {
-    columnView: "slots",
-    daySlots: testDaySlots,
-    locale: "en",
-    mode: "confirm",
-    query: testQuery,
-    months,
-    monthlyView: testMonthlyView,
-    monthsLoading,
-    selected: {
-        start: "2021-09-29T08:00:00Z",
-        end: "2021-09-29T09:00:00Z",
-        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-    },
-    startDateObject: moment("2021-09-01", "YYYY-MM-DD"),
-    endDateObject: moment("2021-10-31", "YYYY-MM-DD"),
-    selectedDay: "2021-09-29",
-    startDay: "sunday",
-    focusedDay: "2021-09-29",
-    focusedSlot: "2021-09-29T08:00:00Z",
-    availableDays: getAvailableDays(testSlotsObject, "Europe/London"),
-    slots: testSlotsObject,
-    slotFetchCount: 1,
-    slotInjectionPoint: undefined,
-    tzid: "Europe/London",
-    populated: true,
-    callback: notification => console.log(notification),
-};
-
-describe("Date Time Picker status reducer", () => {
-    it("CANCEL_SLOT_SELECTION", async () => {
-        const oldState = { ...startingState };
-        const result = statusReducer(oldState, {
-            type: "CANCEL_SLOT_SELECTION",
-        });
-
-        delete oldState.columnView;
-        delete oldState.focusedSlot;
-        delete oldState.selected;
-
-        const { columnView, focusedSlot, selected, ...newState } = result;
-
-        // These values have been updated
-        expect(columnView).toBe("slots");
-        expect(focusedSlot).toBe("2021-09-29T08:00:00Z");
-        expect(selected).toBe(false);
-        // All other values are unchanged
-        expect(newState).toStrictEqual(oldState);
-    });
-
-    it("CONFIRM_SELECTION", async () => {
-        const callbackSpy = jest.spyOn(startingState, "callback");
-        const oldState = { ...startingState };
-        const result = statusReducer(oldState, {
-            type: "CONFIRM_SELECTION",
-            tzid: "Europe/London",
-        });
-
-        const expectedNotification = {
-            notification: {
-                type: "slot_selected",
-                slot: {
-                    start: "2021-09-29T08:00:00Z",
-                    end: "2021-09-29T09:00:00Z",
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                },
-                tzid: "Europe/London",
-            },
-        };
-
-        const { ...newState } = result;
-
-        // These values have been updated
-        expect(callbackSpy).toHaveBeenCalled();
-        expect(callbackSpy).toHaveBeenCalledWith(expectedNotification);
-        // All other values are unchanged
-        expect(newState).toStrictEqual(oldState);
-    });
-
-    it("ERROR_GETTING_SLOTS", async () => {
-        const callbackSpy = jest.spyOn(startingState, "callback");
-        const oldState = { ...startingState };
-        const errorMessage = "fake error message";
-        const result = statusReducer(oldState, {
-            type: "ERROR_GETTING_SLOTS",
-            error: errorMessage,
-        });
-
-        const expectedNotification = {
-            notification: {
-                type: "error",
-                message: "There was an error getting the slots",
-            },
-        };
-
-        delete oldState.columnView;
-
-        const { error, columnView, ...newState } = result;
-
-        // These values have been updated
-        expect(columnView).toBe("error");
-        expect(error).toBe(errorMessage);
-        expect(callbackSpy).toHaveBeenCalled();
-        expect(callbackSpy).toHaveBeenCalledWith(expectedNotification);
-        // All other values are unchanged
-        expect(newState).toStrictEqual(oldState);
-    });
-
-    it("ERROR_LOADING_SLOTS", async () => {
-        const callbackSpy = jest.spyOn(startingState, "callback");
-        const oldState = {
-            ...startingState,
-            months: [
-                {
-                    month: "2021-09",
-                    current: true,
-                    loading: false,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-29T08:00:00Z",
-                                end: "2021-09-30T22:59:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-                {
-                    month: "2021-10",
-                    current: false,
-                    loading: true,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-30T23:00:00Z",
-                                end: "2021-10-04T18:00:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-            ],
-        };
-        const error = {
-            body: {
-                "query_periods[0].end": [
-                    {
-                        key: "errors.max_date_exceeded",
-                        description: "date is too far in the future",
-                    },
-                ],
-            },
-        };
-        const result = statusReducer(oldState, {
-            type: "ERROR_LOADING_SLOTS",
-            error,
-            month: "2021-10",
-        });
-
-        const expectedNotification = {
-            notification: {
-                type: "error",
-                message:
-                    "There was a problem with your availability query. Slots for the month of 2021-10 could not be loaded.",
-                body: {
-                    "query_periods[0].end": [
-                        {
-                            key: "errors.max_date_exceeded",
-                            description: "date is too far in the future",
-                        },
-                    ],
-                },
-            },
-        };
-
-        const expectedResultForMonths = [
-            {
-                month: "2021-09",
-                current: true,
-                loading: false,
-                query: {
-                    max_results: 512,
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                    query_periods: [
-                        {
-                            start: "2021-09-29T08:00:00Z",
-                            end: "2021-09-30T22:59:00Z",
-                        },
-                    ],
-                    required_duration: { minutes: 60 },
-                },
-            },
-            {
-                month: "2021-10",
-                current: false,
-                loading: false,
-                query: {
-                    max_results: 512,
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                    query_periods: [
-                        {
-                            start: "2021-09-30T23:00:00Z",
-                            end: "2021-10-04T18:00:00Z",
-                        },
-                    ],
-                    required_duration: { minutes: 60 },
-                },
-            },
-        ];
-
-        delete oldState.months;
-
-        const { months, ...newState } = result;
-
-        // These values have been updated
-        expect(months).toStrictEqual(expectedResultForMonths);
-        expect(callbackSpy).toHaveBeenCalled();
-        expect(callbackSpy).toHaveBeenCalledWith(expectedNotification);
-        // All other values are unchanged
-        expect(newState).toStrictEqual(oldState);
-    });
-
-    it("NO_SLOTS_FOUND", async () => {
-        const callbackSpy = jest.spyOn(startingState, "callback");
-        const oldState = { ...startingState };
-        const result = statusReducer(oldState, {
-            type: "NO_SLOTS_FOUND",
-        });
-
-        const expectedNotification = {
-            notification: {
-                type: "no_slots_found",
-            },
-        };
-
-        delete oldState.columnView;
-
-        const { columnView, ...newState } = result;
-
-        // These values have been updated
-        expect(columnView).toBe("no-slots");
-        expect(callbackSpy).toHaveBeenCalled();
-        expect(callbackSpy).toHaveBeenCalledWith(expectedNotification);
-        // All other values are unchanged
-        expect(newState).toStrictEqual(oldState);
-    });
-
-    it("RECALCULATE_MONTH_VIEW", async () => {
-        const oldState = { ...startingState };
-        const result = statusReducer(oldState, {
-            type: "RECALCULATE_MONTH_VIEW",
-            tzid: "Europe/London",
-        });
-
-        delete oldState.monthlyView;
-
-        const { monthlyView, ...newState } = result;
-
-        expect(oldState).toStrictEqual(newState);
-        expect(monthlyView).toStrictEqual(testMonthlyView);
-    });
-
-    describe("SET_SLOTS", () => {
-        it("sets initial slots", () => {
-            const oldState = {
-                ...startingState,
-                slots: {},
-                availableDays: [],
-                slotFetchCount: 0,
-                slotInjectionPoint: undefined,
-            };
-
-            const result = statusReducer(oldState, {
-                type: "SET_SLOTS",
-                slots: testSlotsArray,
-                month: "2021-09",
-                tzid: "Europe/London",
-            });
-
-            const expectedResultForMonths = [
-                {
-                    month: "2021-09",
-                    current: true,
-                    loading: false,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-29T08:00:00Z",
-                                end: "2021-09-30T22:59:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-                {
-                    month: "2021-10",
-                    current: false,
-                    loading: true,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-30T23:00:00Z",
-                                end: "2021-10-04T18:00:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-            ];
-
-            delete oldState.slots;
-            delete oldState.availableDays;
-            delete oldState.slotFetchCount;
-            delete oldState.slotInjectionPoint;
-            delete oldState.months;
-
-            const {
-                slots,
-                availableDays,
-                slotFetchCount,
-                slotInjectionPoint,
-                months,
-                ...newState
-            } = result;
-
-            // These values have been updated
-            expect(slots).toStrictEqual(testSlotsObject);
-            expect(availableDays).toStrictEqual([
-                "2021-09-29",
-                "2021-09-30",
-                "2021-10-01",
-                "2021-10-04",
-            ]);
-            expect(slotFetchCount).toBe(1);
-            expect(slotInjectionPoint).toBe("2021-09-29");
-            expect(months).toStrictEqual(expectedResultForMonths);
-
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-
-        it("sets slots when there is only one available slot", () => {
-            const oldState = {
-                ...startingState,
-                slots: {},
-                availableDays: [],
-                slotFetchCount: 0,
-                slotInjectionPoint: undefined,
-            };
-
-            const result = statusReducer(oldState, {
-                type: "SET_SLOTS",
-                slots: testSingleSlotsArray,
-                month: "2021-09",
-                tzid: "Europe/London",
-            });
-
-            delete oldState.slots;
-            delete oldState.availableDays;
-            delete oldState.slotFetchCount;
-            delete oldState.slotInjectionPoint;
-
-            const {
-                slots,
-                availableDays,
-                slotFetchCount,
-                slotInjectionPoint,
-                ...newState
-            } = result;
-
-            // These values have been updated
-            expect(slots).toStrictEqual(testSingleSlotsObject);
-            expect(availableDays).toStrictEqual(["2021-09-29"]);
-            expect(slotFetchCount).toBe(1);
-            expect(slotInjectionPoint).toBe("2021-09-29");
-
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-
-        it("sets slots when there are no slots", () => {
-            const oldState = {
-                ...startingState,
-                slots: {},
-                availableDays: [],
-                slotFetchCount: 0,
-                slotInjectionPoint: undefined,
-            };
-
-            const result = statusReducer(oldState, {
-                type: "SET_SLOTS",
-                slots: [],
-                month: "2021-09",
-                tzid: "Europe/London",
-            });
-
-            delete oldState.slots;
-            delete oldState.availableDays;
-            delete oldState.slotFetchCount;
-            delete oldState.slotInjectionPoint;
-
-            const {
-                slots,
-                availableDays,
-                slotFetchCount,
-                slotInjectionPoint,
-                ...newState
-            } = result;
-
-            // These values have been updated
-            expect(slots).toStrictEqual({});
-            expect(availableDays).toStrictEqual([]);
-            expect(slotFetchCount).toBe(1);
-            expect(slotInjectionPoint).toBe(undefined);
-
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-
-        it("sets additional slots", () => {
-            const oldState = {
-                ...startingState,
-                slots: testSlotsObjectPartial,
-                availableDays: ["2021-09-29", "2021-09-30"],
-                months: [
-                    {
-                        month: "2021-09",
-                        current: true,
-                        loading: false,
-                        query: {
-                            max_results: 512,
-                            participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                            query_periods: [
-                                {
-                                    start: "2021-09-29T08:00:00Z",
-                                    end: "2021-09-30T22:59:00Z",
-                                },
-                            ],
-                            required_duration: { minutes: 60 },
-                        },
-                    },
-                    {
-                        month: "2021-10",
-                        current: false,
-                        loading: true,
-                        query: {
-                            max_results: 512,
-                            participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                            query_periods: [
-                                {
-                                    start: "2021-09-30T23:00:00Z",
-                                    end: "2021-10-04T18:00:00Z",
-                                },
-                            ],
-                            required_duration: { minutes: 60 },
-                        },
-                    },
-                ],
-            };
-
-            const expectedResultForMonths = [
-                {
-                    month: "2021-09",
-                    current: true,
-                    loading: false,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-29T08:00:00Z",
-                                end: "2021-09-30T22:59:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-                {
-                    month: "2021-10",
-                    current: false,
-                    loading: false,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-30T23:00:00Z",
-                                end: "2021-10-04T18:00:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-            ];
-
-            const result = statusReducer(oldState, {
-                type: "SET_SLOTS",
-                slots: testSlotsArrayAdditional,
-                month: "2021-10",
-                tzid: "Europe/London",
-            });
-
-            delete oldState.slots;
-            delete oldState.slotFetchCount;
-            delete oldState.slotInjectionPoint;
-            delete oldState.availableDays;
-            delete oldState.months;
-
-            const {
-                slots,
-                slotFetchCount,
-                slotInjectionPoint,
-                availableDays,
-                months,
-                ...newState
-            } = result;
-
-            expect(slots).toStrictEqual(testSlotsObject);
-            expect(slotFetchCount).toBe(2);
-            expect(slotInjectionPoint).toBe("2021-10-01");
-            expect(availableDays).toStrictEqual([
-                "2021-09-29",
-                "2021-09-30",
-                "2021-10-01",
-                "2021-10-04",
-            ]);
-            expect(months).toStrictEqual(expectedResultForMonths);
-
-            expect(newState).toStrictEqual(oldState);
-        });
-
-        it("sets sequenced slots", () => {
-            const oldState = {
-                ...startingState,
-                query: testSequencedQuery,
-                slots: {},
-                availableDays: [],
-                slotFetchCount: 0,
-                slotInjectionPoint: undefined,
-                sequenced_availability: true,
-            };
-
-            const result = statusReducer(oldState, {
-                type: "SET_SLOTS",
-                slots: testSequencedSlotsArray,
-                month: "2021-09",
-                tzid: "Europe/London",
-            });
-
-            const expectedResultForMonths = [
-                {
-                    month: "2021-09",
-                    current: true,
-                    loading: false,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-29T08:00:00Z",
-                                end: "2021-09-30T22:59:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-                {
-                    month: "2021-10",
-                    current: false,
-                    loading: true,
-                    query: {
-                        max_results: 512,
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                        query_periods: [
-                            {
-                                start: "2021-09-30T23:00:00Z",
-                                end: "2021-10-04T18:00:00Z",
-                            },
-                        ],
-                        required_duration: { minutes: 60 },
-                    },
-                },
-            ];
-
-            delete oldState.slots;
-            delete oldState.availableDays;
-            delete oldState.slotFetchCount;
-            delete oldState.slotInjectionPoint;
-            delete oldState.months;
-
-            const {
-                slots,
-                availableDays,
-                slotFetchCount,
-                slotInjectionPoint,
-                months,
-                ...newState
-            } = result;
-
-            // These values have been updated
-            expect(slots).toStrictEqual(testSequencedSlotsObject);
-            expect(availableDays).toStrictEqual([
-                "2021-09-29",
-                "2021-09-30",
-                "2021-10-01",
-                "2021-10-04",
-            ]);
-            expect(slotFetchCount).toBe(1);
-            expect(slotInjectionPoint).toBe("2021-09-29");
-            expect(months).toStrictEqual(expectedResultForMonths);
-
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-    });
-
-    it("SET_FOCUS", async () => {
-        const oldState = { ...startingState };
-        const date = "2021-09-29";
-        const result = statusReducer(oldState, {
-            type: "SET_FOCUS",
-            focusedDay: date,
-        });
-
-        delete oldState.focusedDay;
-
-        const { focusedDay, ...newState } = result;
-
-        // These values have been updated
-        expect(focusedDay).toBe(date);
-        // All other values are unchanged
-        expect(newState).toStrictEqual(oldState);
-    });
-
-    describe("SELECT_DAY", () => {
-        it("SELECT_DAY", async () => {
-            const oldState = { ...startingState };
-            const date = "2021-10-04";
-            const result = statusReducer(oldState, {
-                type: "SELECT_DAY",
-                day: date,
-            });
-
-            const expectedDaySlots = [
-                {
-                    start: "2021-10-04T09:00:00Z",
-                    end: "2021-10-04T10:00:00Z",
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                },
-                {
-                    start: "2021-10-04T10:00:00Z",
-                    end: "2021-10-01T11:00:00Z",
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                },
-                {
-                    start: "2021-10-04T11:00:00Z",
-                    end: "2021-10-04T12:00:00Z",
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                },
-                {
-                    start: "2021-10-04T15:00:00Z",
-                    end: "2021-10-04T16:00:00Z",
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                },
-                {
-                    start: "2021-10-04T17:00:00Z",
-                    end: "2021-10-04T18:00:00Z",
-                    participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                },
-            ];
-
-            delete oldState.selectedDay;
-            delete oldState.focusedDay;
-            delete oldState.focusedSlot;
-            delete oldState.columnView;
-            delete oldState.daySlots;
-
-            const {
-                selectedDay,
-                focusedDay,
-                focusedSlot,
-                columnView,
-                daySlots,
-                ...newState
-            } = result;
-
-            // These values have been updated
-            expect(selectedDay).toBe(date);
-            expect(focusedDay).toBe(date);
-            expect(focusedSlot).toBe("2021-10-04T09:00:00Z");
-            expect(daySlots).toStrictEqual(expectedDaySlots);
-            expect(columnView).toBe("slots");
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-
-        it("SELECT_DAY for sequenced slots", async () => {
-            const oldState = {
-                ...startingState,
-                slots: testSequencedSlotsObject,
-                sequenced_availability: true,
-            };
-            const date = "2021-09-29";
-            const result = statusReducer(oldState, {
-                type: "SELECT_DAY",
-                day: date,
-            });
-
-            delete oldState.selectedDay;
-            delete oldState.focusedDay;
-            delete oldState.focusedSlot;
-            delete oldState.columnView;
-            delete oldState.daySlots;
-
-            const {
-                selectedDay,
-                focusedDay,
-                focusedSlot,
-                columnView,
-                daySlots,
-                ...newState
-            } = result;
-
-            // These values have been updated
-            expect(selectedDay).toBe(date);
-            expect(focusedDay).toBe(date);
-            expect(focusedSlot).toBe("2021-09-29T08:00:00Z");
-            expect(daySlots).toStrictEqual(testDaySequencedSlots);
-            expect(columnView).toBe("slots");
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-    });
-
-    describe("SELECT_MONTH", () => {
-        it("doesn't select month if month before start bound", () => {
-            const oldState = { ...startingState };
-            const month = "2021-08";
-            const result = statusReducer(oldState, {
-                type: "SELECT_MONTH",
-                month,
-                tzid: "Europe/London",
-            });
-
-            expect(result).toStrictEqual(oldState);
-        });
-
-        it("doesn't select month if month outside end bound", () => {
-            const oldState = { ...startingState };
-            const month = "2021-11";
-            const result = statusReducer(oldState, {
-                type: "SELECT_MONTH",
-                month,
-                tzid: "Europe/London",
-            });
-
-            expect(result).toStrictEqual(oldState);
-        });
-
-        describe("within start and end bound", () => {
-            it("selects month within start and end bound", () => {
-                const oldState = { ...startingState };
-                const month = "2021-10";
-                const result = statusReducer(oldState, {
-                    type: "SELECT_MONTH",
-                    month: month,
-                    tzid: "Europe/London",
-                });
-
-                const expectedResultForMonths = [
-                    {
-                        month: "2021-09",
-                        current: false,
-                        loading: false,
-                        query: {
-                            max_results: 512,
-                            participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                            query_periods: [
-                                {
-                                    start: "2021-09-29T08:00:00Z",
-                                    end: "2021-09-30T22:59:00Z",
-                                },
-                            ],
-                            required_duration: { minutes: 60 },
-                        },
-                    },
-                    {
-                        month: "2021-10",
-                        current: true,
-                        loading: true,
-                        query: {
-                            max_results: 512,
-                            participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                            query_periods: [
-                                {
-                                    start: "2021-09-30T23:00:00Z",
-                                    end: "2021-10-04T18:00:00Z",
-                                },
-                            ],
-                            required_duration: { minutes: 60 },
-                        },
-                    },
-                ];
-
-                delete oldState.months;
-                delete oldState.focusedDay;
-                delete oldState.monthlyView;
-
-                const { focusedDay, months, monthlyView, ...newState } = result;
-
-                // These values have been updated
-                expect(focusedDay).toBe(false);
-                expect(monthlyView).toStrictEqual(testMonthlySlots[1]);
-                expect(months).toStrictEqual(expectedResultForMonths);
-
-                // All other values are unchanged
-                expect(newState).toStrictEqual(oldState);
-            });
-
-            it("selects month with focusedDay", () => {
-                const oldState = { ...startingState };
-                const month = "2021-10";
-                const date = "2021-10-09";
-
-                const result = statusReducer(oldState, {
-                    type: "SELECT_MONTH",
-                    month: month,
-                    focusedDay: date,
-                    tzid: "Europe/London",
-                });
-
-                const expectedResultForMonths = [
-                    {
-                        month: "2021-09",
-                        current: false,
-                        loading: false,
-                        query: {
-                            max_results: 512,
-                            participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                            query_periods: [
-                                {
-                                    start: "2021-09-29T08:00:00Z",
-                                    end: "2021-09-30T22:59:00Z",
-                                },
-                            ],
-                            required_duration: { minutes: 60 },
-                        },
-                    },
-                    {
-                        month: "2021-10",
-                        current: true,
-                        loading: true,
-                        query: {
-                            max_results: 512,
-                            participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                            query_periods: [
-                                {
-                                    start: "2021-09-30T23:00:00Z",
-                                    end: "2021-10-04T18:00:00Z",
-                                },
-                            ],
-                            required_duration: { minutes: 60 },
-                        },
-                    },
-                ];
-
-                delete oldState.months;
-                delete oldState.focusedDay;
-                delete oldState.monthlyView;
-
-                const { focusedDay, months, monthlyView, ...newState } = result;
-
-                // These values have been updated
-                expect(focusedDay).toBe(date);
-                expect(monthlyView).toStrictEqual(testMonthlySlots[1]);
-                expect(months).toStrictEqual(expectedResultForMonths);
-
-                // All other values are unchanged
-                expect(newState).toStrictEqual(oldState);
-            });
-        });
-    });
-
-    describe("SELECT_SLOT", () => {
-        it("SELECT_SLOT", async () => {
-            const oldState = { ...startingState };
-            const slot = {
-                start: "2021-09-30T14:00:00Z",
-                end: "2021-09-30T15:00:00Z",
-                participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-            };
-            const result = statusReducer(oldState, {
-                type: "SELECT_SLOT",
-                slot: slot,
-            });
-
-            delete oldState.selected;
-            delete oldState.focusedSlot;
-            delete oldState.columnView;
-
-            const { selected, focusedSlot, columnView, ...newState } = result;
-
-            // These values have been updated
-            expect(selected).toStrictEqual(slot);
-            expect(focusedSlot).toBe("2021-09-30T14:00:00Z");
-            expect(columnView).toBe("confirm");
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-
-        it("SELECT_SLOT for sequenced availability", async () => {
-            const oldState = { ...startingState };
-            const slot = {
-                start: "2021-09-29T10:00:00Z",
-                end: "2021-09-29T11:30:00Z",
-                sequence: [
-                    {
-                        sequence_id: "test-one",
-                        start: "2021-09-29T10:00:00Z",
-                        end: "2021-09-29T11:00:00Z",
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                    },
-                    {
-                        sequence_id: "test-two",
-                        start: "2021-09-29T11:00:00Z",
-                        end: "2021-09-29T11:30:00Z",
-                        participants: [{ sub: "acc_5f35432b3f07d06753082354" }],
-                    },
-                ],
-            };
-            const result = statusReducer(oldState, {
-                type: "SELECT_SLOT",
-                slot: slot,
-            });
-
-            delete oldState.selected;
-            delete oldState.focusedSlot;
-            delete oldState.columnView;
-
-            const { selected, focusedSlot, columnView, ...newState } = result;
-
-            // These values have been updated
-            expect(selected).toStrictEqual(slot);
-            expect(focusedSlot).toBe("2021-09-29T10:00:00Z");
-            expect(columnView).toBe("confirm");
-            // All other values are unchanged
-            expect(newState).toStrictEqual(oldState);
-        });
-    });
-
-    it("SELECT_TZID", async () => {
-        const oldState = { ...startingState };
-        const timezone = {
-            tzid: "Asia/Kathmandu",
-            offset: "+05:45",
-            offsetMins: 345,
-            name: "Kathmandu",
-            abbr: "+0545",
-        };
-        const result = statusReducer(oldState, {
-            type: "SELECT_TZID",
-            tzid: timezone.tzid,
-        });
-
-        delete oldState.availableDays;
-        delete oldState.daySlots;
-        delete oldState.monthlyView;
-
-        const { availableDays, daySlots, monthlyView, ...newState } = result;
-
-        // These values have been updated
-        expect(availableDays).toStrictEqual([
-            "2021-09-29",
-            "2021-09-30",
-            "2021-10-01",
-            "2021-10-04",
-        ]);
-        expect(daySlots).toStrictEqual(testDaySlots);
-        expect(monthlyView).toStrictEqual(testMonthlyView);
-        // All other values are unchanged
-        expect(newState).toStrictEqual(oldState);
-    });
-});