cronofy-elements 1.48.1 → 1.49.1

package/tests/init.AvailabilityViewer.test.js

@@ -1,740 +0,0 @@
-import moment from "moment-timezone";
-import { parseAvailabilityViewerOptions } from "../src/js/helpers/init.AvailabilityViewer";
-import { parseGridTime } from "../src/js/helpers/init";
-
-// The parsers rely on console warning and errors to
-// comunicate problems to the users
-console.error = jest.fn();
-console.warn = jest.fn();
-
-beforeEach(() => {
-    console.error.mockClear();
-    console.warn.mockClear();
-});
-
-const generic_query_periods = [
-    {
-        start: moment().toISOString(),
-        end: moment().add(1, "days").toISOString(),
-    },
-];
-
-describe("Parsing AvailabilityViewer options", () => {
-    const sniffedTimezone = moment.tz.guess();
-
-    it("works when all options are declared", () => {
-        const input = {
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                allow_expansion: true,
-                bounds_control: true,
-                start_time: "01:00",
-                end_time: "02:00",
-                interval: 60,
-                week_start_day: "monday",
-            },
-            data_center: "DATA_CENTER",
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            tzid: sniffedTimezone,
-        };
-        const expectedOutput = {
-            config: {
-                allowExpansion: true,
-                boundsControl: true,
-                end_time: "02:00",
-                interval: 60,
-                logs: "warn",
-                mode: "confirm",
-                slot_selection: "available",
-                startDay: "monday",
-                start_time: "01:00",
-            },
-            customtzid: true,
-            data_center: "DATA_CENTER",
-            domains: {
-                apiDomain: "https://api-DATA_CENTER.cronofy.com",
-                appDomain: "https://app-DATA_CENTER.cronofy.com",
-            },
-            error: false,
-            query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target: "TARGET",
-            token: "TOKEN",
-            tzid: sniffedTimezone,
-        };
-        const result = parseAvailabilityViewerOptions(input);
-        expect(result.config).toEqual(expectedOutput.config);
-        expect(result.customtzid).toEqual(expectedOutput.customtzid);
-        expect(result.data_center).toEqual(expectedOutput.data_center);
-        expect(result.domains).toEqual(expectedOutput.domains);
-        expect(result.error).toEqual(expectedOutput.error);
-        expect(result.query).toEqual(expectedOutput.query);
-        expect(result.target).toEqual(expectedOutput.target);
-        expect(result.token).toEqual(expectedOutput.token);
-        expect(result.tzid).toEqual(expectedOutput.tzid);
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-
-    it("returns an error if there is no query present when all other required options are declared", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            tzid: sniffedTimezone,
-            config: { start_time: "01:00", end_time: "02:00" },
-        };
-
-        const output = parseAvailabilityViewerOptions(input);
-
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-
-    it("fails if there is no token declared", () => {
-        expect(parseAvailabilityViewerOptions()).toEqual(false);
-        expect(console.error).toHaveBeenCalledTimes(1);
-    });
-
-    it("continues if there is no token declared, but we're in demo mode", () => {
-        const output = parseAvailabilityViewerOptions({
-            demo: true,
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: { start_time: "01:00", end_time: "02:00" },
-        });
-
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.token).toEqual(false);
-        expect(output.target).toEqual("cronofy-element-availability-viewer");
-        expect(output.tzid).toEqual(sniffedTimezone);
-
-        expect(console.warn).toHaveBeenCalledTimes(2);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default target if there is no target option", () => {
-        const output = parseAvailabilityViewerOptions({
-            element_token: "TOKEN",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: { start_time: "01:00", end_time: "02:00" },
-        });
-        expect(output.token).toEqual("TOKEN");
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.target).toEqual("cronofy-element-availability-viewer");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default domains if there is no data_center option", () => {
-        const expectedDomains = {
-            apiDomain: "https://api.cronofy.com",
-            appDomain: "https://app.cronofy.com",
-        };
-
-        const output = parseAvailabilityViewerOptions({
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: { start_time: "01:00", end_time: "02:00" },
-        });
-        expect(output.token).toEqual("TOKEN");
-        expect(output.target).toEqual("TARGET");
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.domains).toEqual(expectedDomains);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("creates correct domains if there is a data_center option", () => {
-        const expectedDomains = {
-            apiDomain: "https://api-de.cronofy.com",
-            appDomain: "https://app-de.cronofy.com",
-        };
-
-        const output = parseAvailabilityViewerOptions({
-            data_center: "de",
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: { start_time: "01:00", end_time: "02:00" },
-        });
-        expect(output.token).toEqual("TOKEN");
-        expect(output.target).toEqual("TARGET");
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.domains).toEqual(expectedDomains);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses the config.mode", () => {
-        const output = parseAvailabilityViewerOptions({
-            data_center: "de",
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: {
-                mode: "multi_select",
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-        });
-
-        expect(output.token).toEqual("TOKEN");
-        expect(output.target).toEqual("TARGET");
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.config.mode).toEqual("multi_select");
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses an empty config.mode", () => {
-        const output = parseAvailabilityViewerOptions({
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: { start_time: "01:00", end_time: "02:00" },
-        });
-
-        expect(output.token).toEqual("TOKEN");
-        expect(output.target).toEqual("TARGET");
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.config.mode).toEqual("confirm");
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses the config.customBounds", () => {
-        const output = parseAvailabilityViewerOptions({
-            data_center: "de",
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: {
-                bounds_control: true,
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-        });
-
-        expect(output.token).toEqual("TOKEN");
-        expect(output.target).toEqual("TARGET");
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.config.boundsControl).toEqual(true);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses an empty config.customBounds", () => {
-        const output = parseAvailabilityViewerOptions({
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: { start_time: "01:00", end_time: "02:00" },
-        });
-
-        expect(output.token).toEqual("TOKEN");
-        expect(output.target).toEqual("TARGET");
-        expect(output.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(output.config.boundsControl).toEqual(false);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses default config.slotSelection", () => {
-        const defaultOutput = parseAvailabilityViewerOptions({
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: {
-                slot_selection: "availability",
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-        });
-
-        expect(defaultOutput.config.slot_selection).toEqual("availability");
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses empty config.slotSelection", () => {
-        const withoutSelection = parseAvailabilityViewerOptions({
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-        });
-
-        expect(withoutSelection.config.slot_selection).toEqual("available");
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses config.slotSelection", () => {
-        const withSelection = parseAvailabilityViewerOptions({
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: {
-                slot_selection: "restricted",
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-        });
-
-        expect(withSelection.config.slot_selection).toEqual("restricted");
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses tzid option", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            tzid: sniffedTimezone,
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.customtzid).toEqual(true);
-        expect(result.tzid).toEqual(sniffedTimezone);
-    });
-
-    it("correctly falls back when given an invalid tzid option", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            tzid: "A_NON_IANA_TZID",
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.customtzid).toEqual(true);
-        expect(result.tzid).toEqual(sniffedTimezone);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-    });
-
-    it("correctly adds a fallback tzid option", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                start_time: "01:00",
-                end_time: "02:00",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.customtzid).toEqual(false);
-        expect(result.tzid).toEqual(sniffedTimezone);
-    });
-
-    it("correctly adds fallback config.start_time and config.end_time", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.config.start_time).toEqual("09:00");
-        expect(result.config.end_time).toEqual("17:00");
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly fallbacks when config.start_time is invalid", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                start_time: "A string that is not a time",
-                end_time: "13:00",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.config.start_time).toEqual("09:00");
-        expect(result.config.end_time).toEqual("13:00");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.start_time: using default value of 09:00"
-        );
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly fallbacks when config.end_time is invalid", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                start_time: "08:00",
-                end_time: 1234,
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.config.start_time).toEqual("08:00");
-        expect(result.config.end_time).toEqual("17:00");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.end_time: using default value of 17:00"
-        );
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly rounds config.start_time to valid interval", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            config: {
-                start_time: "08:25",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.config.start_time).toEqual("08:15");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.start_time: rounded from 08:25 to 08:15"
-        );
-    });
-
-    it("correctly rounds config.start_time to valid interval", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-
-        const config_1 = {
-            config: {
-                end_time: "17:25",
-            },
-        };
-        const result_1 = parseAvailabilityViewerOptions({
-            ...input,
-            ...config_1,
-        });
-
-        expect(result_1.config.end_time).toEqual("17:30");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.end_time: rounded from 17:25 to 17:30"
-        );
-
-        console.warn.mockClear();
-
-        const config_2 = {
-            config: {
-                start_time: "08:38",
-            },
-        };
-        const result_2 = parseAvailabilityViewerOptions({
-            ...input,
-            ...config_2,
-        });
-
-        expect(result_2.config.start_time).toEqual("08:30");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.start_time: rounded from 08:38 to 08:30"
-        );
-    });
-
-    it("adjusts config.interval to match config.start_time when needed", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-
-        const config_1 = {
-            config: {
-                start_time: "08:30",
-                interval: 60,
-            },
-        };
-        const result_1 = parseAvailabilityViewerOptions({
-            ...input,
-            ...config_1,
-        });
-
-        expect(result_1.config.interval).toEqual(30);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.interval of 60 minutes has been shortened to 30 minutes for optimal tessellation of results in the grid."
-        );
-
-        console.warn.mockClear();
-
-        const config_2 = {
-            config: {
-                start_time: "08:15",
-                interval: 60,
-            },
-        };
-        const result_2 = parseAvailabilityViewerOptions({
-            ...input,
-            ...config_2,
-        });
-
-        expect(result_2.config.interval).toEqual(15);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.interval of 60 minutes has been shortened to 15 minutes for optimal tessellation of results in the grid."
-        );
-
-        console.warn.mockClear();
-
-        const config_3 = {
-            config: {
-                start_time: "08:45",
-                interval: 60,
-            },
-        };
-        const result_3 = parseAvailabilityViewerOptions({
-            ...input,
-            ...config_3,
-        });
-
-        expect(result_3.config.interval).toEqual(15);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.warn.mock.calls[0][0]).toContain(
-            "config.interval of 60 minutes has been shortened to 15 minutes for optimal tessellation of results in the grid."
-        );
-    });
-
-    it("fails if start_time is after end_time", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            config: {
-                start_time: "08:00",
-                end_time: "06:00",
-                interval: 60,
-            },
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result).toEqual(false);
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.error.mock.calls[0][0]).toContain("must be earlier than");
-    });
-
-    it("converts midnight end_time to 24:00", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            config: {
-                start_time: "08:00",
-                end_time: "00:00",
-                interval: 60,
-            },
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.config.end_time).toEqual("24:00");
-    });
-
-    it("correctly parses grid times", () => {
-        const simpleTime = parseGridTime("08:00");
-        expect(simpleTime.time).toBe("08:00");
-        expect(simpleTime.offset).toBe(0);
-        expect(simpleTime.message).toBe(false);
-
-        const offsetTime = parseGridTime("08:30");
-        expect(offsetTime.time).toBe("08:30");
-        expect(offsetTime.offset).toBe(30);
-        expect(offsetTime.message).toBe(false);
-
-        const invalidTime = parseGridTime("INVALID");
-        expect(invalidTime.time).toBe("09:00");
-        expect(invalidTime.offset).toBe(0);
-        expect(invalidTime.message).toContain("using default value");
-
-        const roundedDown = parseGridTime("08:42");
-        expect(roundedDown.time).toBe("08:30");
-        expect(roundedDown.offset).toBe(30);
-        expect(roundedDown.message).toContain("rounded");
-
-        const roundedUp = parseGridTime("08:42", "", true);
-        expect(roundedUp.time).toBe("08:45");
-        expect(roundedUp.offset).toBe(45);
-        expect(roundedUp.message).toContain("rounded");
-
-        const noLeadingZeroTime = parseGridTime("8:00");
-        expect(noLeadingZeroTime.time).toBe("09:00");
-        expect(noLeadingZeroTime.offset).toBe(0);
-        expect(noLeadingZeroTime.message).toContain("using default value");
-
-        const emptyTime = parseGridTime();
-        expect(emptyTime.time).toBe("09:00");
-        expect(emptyTime.offset).toBe(0);
-        expect(emptyTime.message).toBe(false);
-
-        const customFallbackTime = parseGridTime("INVALID", "06:00");
-        expect(customFallbackTime.time).toBe("06:00");
-        expect(customFallbackTime.offset).toBe(0);
-        expect(customFallbackTime.message).toContain("using default value");
-    });
-
-    it("correctly adds config.allowExpansion", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.config).toHaveProperty("allowExpansion");
-        expect(result.config.allowExpansion).toBe(false);
-    });
-
-    it("correctly parses config.allow_expansion", () => {
-        const input = {
-            data_center: "DATA_CENTER",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            config: {
-                allow_expansion: true,
-            },
-        };
-        const result = parseAvailabilityViewerOptions(input);
-
-        expect(result.config).toHaveProperty("allowExpansion");
-        expect(result.config).not.toHaveProperty("allow_expansion");
-        expect(result.config.allowExpansion).toBe(true);
-    });
-});