cronofy-elements 1.48.1 → 1.49.1

package/tests/init.SlotPicker.test.js

@@ -1,166 +0,0 @@
-import moment from "moment-timezone";
-import { parseSlotPickerOptions } from "../src/js/helpers/init.SlotPicker";
-
-// 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 SlotPicker options", () => {
-    it("works when all options are declared", () => {
-        const input = {
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-        };
-
-        const result = parseSlotPickerOptions(input);
-        expect(result.config).toEqual({
-            mode: "confirm",
-            logs: "warn",
-        });
-        expect(result.domains).toEqual({
-            apiDomain: "https://api.cronofy.com",
-            appDomain: "https://app.cronofy.com",
-        });
-        expect(result.query).toEqual({
-            query_periods: generic_query_periods,
-            required_duration: "TEST",
-        });
-        expect(result.target).toEqual("TARGET");
-        expect(result.token).toEqual("TOKEN");
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-
-    it("fails if there is no token declared", () => {
-        expect(parseSlotPickerOptions()).toEqual(false);
-        expect(console.error).toHaveBeenCalledTimes(1);
-    });
-
-    it("continues if there is no token declared, but we're in demo mode", () => {
-        const expectedOutput = {
-            config: {
-                mode: "confirm",
-                logs: "warn",
-            },
-            demo: true,
-            domains: {
-                apiDomain: "https://api.cronofy.com",
-                appDomain: "https://app.cronofy.com",
-            },
-            query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-            target: "cronofy-element-slot-picker",
-            token: false,
-        };
-        const result = parseSlotPickerOptions({
-            demo: true,
-            availability_query: {
-                query_periods: generic_query_periods,
-                required_duration: "TEST",
-            },
-        });
-        expect(result.config).toEqual(expectedOutput.config);
-        expect(result.domains).toEqual(expectedOutput.domains);
-        expect(result.target).toEqual(expectedOutput.target);
-        expect(console.warn).toHaveBeenCalledTimes(2);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default target if there is no target option", () => {
-        expect(
-            parseSlotPickerOptions({
-                availability_query: {
-                    query_periods: generic_query_periods,
-                    required_duration: "TEST",
-                },
-                element_token: "TOKEN",
-            }).target
-        ).toEqual("cronofy-element-slot-picker");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default domains if there is no data_center option", () => {
-        expect(
-            parseSlotPickerOptions({
-                availability_query: {
-                    query_periods: generic_query_periods,
-                    required_duration: "TEST",
-                },
-                element_token: "TOKEN",
-                target_id: "TARGET",
-            }).domains
-        ).toEqual({
-            apiDomain: "https://api.cronofy.com",
-            appDomain: "https://app.cronofy.com",
-        });
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("creates correct domains if there is a data_center option", () => {
-        expect(
-            parseSlotPickerOptions({
-                availability_query: {
-                    query_periods: generic_query_periods,
-                    required_duration: "TEST",
-                },
-                data_center: "de",
-                element_token: "TOKEN",
-                target_id: "TARGET",
-            }).domains
-        ).toEqual({
-            apiDomain: "https://api-de.cronofy.com",
-            appDomain: "https://app-de.cronofy.com",
-        });
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("passes query through unchanged if bookable_events are present", () => {
-        const result = parseSlotPickerOptions({
-            availability_query: {
-                bookable_events: ["EVENT", "EVENT"],
-                test: "UNKNOWN_KEY",
-            },
-            element_token: "TOKEN",
-            target_id: "TARGET",
-        });
-        expect(result).toHaveProperty("query");
-        expect(result.query.bookable_events.length).toBe(2);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("errors if query does not contain query_periods", () => {
-        const result = parseSlotPickerOptions({
-            availability_query: {
-                test: "UNKNOWN_KEY",
-            },
-            element_token: "TOKEN",
-            target_id: "TARGET",
-        });
-        expect(result).toHaveProperty("query");
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(1);
-    });
-});

package/tests/init.test.js

@@ -1,231 +0,0 @@
-import { parseQuery } 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();
-});
-
-describe("Parsing query_periods", () => {
-    let log = {
-        error: jest.fn(),
-        warn: jest.fn(),
-    };
-
-    beforeEach(() => {
-        log.error.mockClear();
-        log.warn.mockClear();
-    });
-
-    it("returns an error if query_periods is not provided", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: { start_time: "01:00", end_time: "02:00" },
-            availability_query: {},
-        };
-
-        const output = parseQuery({
-            options: input,
-            elementSlug: "docs-slug",
-            log,
-        });
-
-        expect(log.error).toHaveBeenCalledWith(
-            expect.stringMatching(
-                "You need to provide an `availability_query.query_periods` option."
-            ),
-            { docsSlug: "availability-viewer/#availability_query" }
-        );
-    });
-
-    it("returns an error if query_periods is not an array", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: { start_time: "01:00", end_time: "02:00" },
-            availability_query: {
-                query_periods: { hello: "world" },
-            },
-        };
-
-        const output = parseQuery({
-            options: input,
-            elementSlug: "docs-slug",
-            log,
-        });
-
-        expect(log.error).toHaveBeenCalledWith(expect.stringMatching("not an array"), {
-            docsSlug: "availability-viewer/#availability_query",
-        });
-    });
-
-    it("returns an error if query_periods is an empty array", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: { start_time: "01:00", end_time: "02:00" },
-            availability_query: {
-                query_periods: [],
-            },
-        };
-
-        const output = parseQuery({
-            options: input,
-            elementSlug: "docs-slug",
-            log,
-        });
-
-        expect(log.error).toHaveBeenCalledWith(
-            expect.stringMatching(
-                "The provided `availability_query.query_periods` option is empty."
-            ),
-            { docsSlug: "availability-viewer/#availability_query" }
-        );
-    });
-
-    it("returns an warning if query_periods is an empty array but allowEmpty flag is set", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: { start_time: "01:00", end_time: "02:00" },
-            availability_query: {
-                query_periods: [],
-                required_duration: "TEST",
-            },
-        };
-
-        const output = parseQuery({
-            options: input,
-            elementSlug: "docs-slug",
-            log,
-            allowEmpty: true,
-        });
-
-        expect(log.error.mock.calls.length).toBe(0);
-        expect(log.warn.mock.calls.length).toBe(1);
-        expect(log.warn).toHaveBeenCalledWith(
-            expect.stringMatching(
-                "The provided `availability_query.query_periods` option is empty."
-            ),
-            { docsSlug: "availability-viewer/#availability_query" }
-        );
-    });
-
-    it("returns an error if query_periods cannot be parsed as dates", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: { start_time: "01:00", end_time: "02:00" },
-            availability_query: {
-                query_periods: [{ start: "hello", end: "world" }],
-            },
-        };
-
-        const output = parseQuery({
-            options: input,
-            elementSlug: "docs-slug",
-            log,
-        });
-
-        expect(log.error).toHaveBeenCalledWith(
-            expect.stringMatching(
-                "Some of the provided `availability_query.query_periods` option have errors."
-            ),
-            {
-                docsSlug: "availability-viewer/#availability_query",
-                errorObject: expect.objectContaining({
-                    "query_period[0]": [
-                        "start must be a valid date string",
-                        "end must be a valid date string",
-                    ],
-                }),
-            }
-        );
-    });
-
-    it("returns an error if query_periods are not objects", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: { start_time: "01:00", end_time: "02:00" },
-            availability_query: {
-                query_periods: [null, 5, "nope", {}, { foo: 3 }],
-            },
-        };
-
-        const output = parseQuery({
-            options: input,
-            elementSlug: "docs-slug",
-            log,
-        });
-
-        expect(log.error).toHaveBeenCalledWith(
-            expect.stringMatching(
-                "Some of the provided `availability_query.query_periods` option have errors."
-            ),
-            {
-                docsSlug: "availability-viewer/#availability_query",
-                errorObject: expect.objectContaining({
-                    "query_period[0]": [
-                        "query period must be an object with start and end properties",
-                    ],
-                    "query_period[1]": [
-                        "query period must be an object with start and end properties",
-                    ],
-                    "query_period[2]": [
-                        "query period must be an object with start and end properties",
-                    ],
-                    "query_period[3]": [
-                        "query period must be an object with start and end properties",
-                    ],
-                    "query_period[3]": [
-                        "query period must be an object with start and end properties",
-                    ],
-                }),
-            }
-        );
-    });
-
-    it("returns an error if one of the query_periods has the start after the end", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            config: { start_time: "01:00", end_time: "02:00" },
-            availability_query: {
-                query_periods: [
-                    {
-                        start: "2020-10-21T13:15:00Z",
-                        end: "2020-10-21T17:15:00Z",
-                    }, // OK
-                    {
-                        start: "2020-10-23T13:15:00Z",
-                        end: "2020-10-22T13:15:00Z",
-                    }, // End == Start
-                ],
-            },
-        };
-
-        const output = parseQuery({
-            options: input,
-            elementSlug: "docs-slug",
-            log,
-        });
-
-        expect(log.error).toHaveBeenCalledWith(
-            expect.stringMatching(
-                "Some of the provided `availability_query.query_periods` option have errors."
-            ),
-            {
-                docsSlug: "availability-viewer/#availability_query",
-                errorObject: expect.objectContaining({
-                    "query_period[1]": ["end must be after start"],
-                }),
-            }
-        );
-    });
-});

package/tests/logging.test.js

@@ -1,235 +0,0 @@
-import { buildLogNotification, logConstructor } from "../src/js/helpers/logging";
-
-// The parsers rely on console warning and errors to
-// comunicate problems to the users
-console.error = jest.fn();
-console.info = jest.fn();
-console.log = jest.fn();
-console.warn = jest.fn();
-
-const messageTemplate = (type, message, slug) =>
-    `UI Elements: ${type}\n${message}\nhttps://docs.cronofy.com/developers/ui-elements/${slug}\n`;
-
-beforeEach(() => {
-    console.error.mockClear();
-    console.info.mockClear();
-    console.log.mockClear();
-    console.warn.mockClear();
-});
-
-describe("Logging", () => {
-    it("works in `info` mode", () => {
-        const log = logConstructor("info");
-        log.error("message");
-        log.warn("message");
-        log.info("message");
-        log.log("message");
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.info).toHaveBeenCalledTimes(1);
-        expect(console.log).toHaveBeenCalledTimes(1);
-    });
-
-    it("works in `warn` mode", () => {
-        const log = logConstructor("warn");
-        log.error("message");
-        log.warn("message");
-        log.info("message");
-        log.log("message");
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.info).toHaveBeenCalledTimes(0);
-        expect(console.log).toHaveBeenCalledTimes(0);
-    });
-
-    it("works in `error` mode", () => {
-        const log = logConstructor("error");
-        log.error("message");
-        log.warn("message");
-        log.info("message");
-        log.log("message");
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.info).toHaveBeenCalledTimes(0);
-        expect(console.log).toHaveBeenCalledTimes(0);
-    });
-
-    it("works in `none` mode", () => {
-        const log = logConstructor("none");
-        log.error("message");
-        log.warn("message");
-        log.info("message");
-        log.log("message");
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.info).toHaveBeenCalledTimes(0);
-        expect(console.log).toHaveBeenCalledTimes(0);
-    });
-
-    it("defaults to `warn` mode", () => {
-        const log = logConstructor();
-        log.error("message");
-        log.warn("message");
-        log.info("message");
-        log.log("message");
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.info).toHaveBeenCalledTimes(0);
-        expect(console.log).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly creates a log", () => {
-        const log = logConstructor("info");
-        log.info("TEST MESSAGE");
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.info).toHaveBeenCalledTimes(1);
-        expect(console.log).toHaveBeenCalledTimes(0);
-        expect(console.info.mock.calls[0][0]).toEqual(
-            messageTemplate("General", "TEST MESSAGE", "")
-        );
-        expect(console.info.mock.calls[0][1]).toBe(undefined);
-    });
-
-    it("ignores unwanted properties", () => {
-        const log = logConstructor("info");
-        log.info("TEST MESSAGE", { unwanted: "THING" });
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.info).toHaveBeenCalledTimes(1);
-        expect(console.log).toHaveBeenCalledTimes(0);
-        expect(console.info.mock.calls[0][0]).toEqual(
-            messageTemplate("General", "TEST MESSAGE", "")
-        );
-        expect(console.info.mock.calls[0][1]).toBe(undefined);
-    });
-
-    it("adds wanted properties to the log output", () => {
-        const log = logConstructor("info");
-        log.info("TEST MESSAGE", { errorObject: "THING" });
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.info).toHaveBeenCalledTimes(1);
-        expect(console.log).toHaveBeenCalledTimes(0);
-        expect(console.info.mock.calls[0][0]).toEqual(
-            messageTemplate("General", "TEST MESSAGE", "")
-        );
-        expect(console.info.mock.calls[0][1]).toBe("THING");
-    });
-
-    it("adds slug to end of docs URL when needed", () => {
-        const log = logConstructor("info");
-        log.info("TEST MESSAGE", { docsSlug: "TEST" });
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.info).toHaveBeenCalledTimes(1);
-        expect(console.log).toHaveBeenCalledTimes(0);
-        expect(console.info.mock.calls[0][0]).toEqual(
-            messageTemplate("General", "TEST MESSAGE", "TEST")
-        );
-        expect(console.info.mock.calls[0][1]).toBe(undefined);
-    });
-
-    it("adds docs URL slug, and extra props (and ignores unwanted props)", () => {
-        const log = logConstructor("info");
-        log.info("TEST MESSAGE", {
-            docsSlug: "TEST",
-            errorObject: "THING",
-            unwanted: "THING",
-        });
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.info).toHaveBeenCalledTimes(1);
-        expect(console.log).toHaveBeenCalledTimes(0);
-        expect(console.info.mock.calls[0][0]).toEqual(
-            messageTemplate("General", "TEST MESSAGE", "TEST")
-        );
-        expect(console.info.mock.calls[0][1]).toBe("THING");
-        expect(console.info.mock.calls[0][2]).toBe(undefined);
-    });
-
-    it("calls provided callback", () => {
-        const callback = jest.fn();
-        const expectedNotification = {
-            notification: {
-                element: "ELEMENT_NAME",
-                errors: {},
-                message: "TEST MESSAGE",
-                type: "error",
-                url: "https://docs.cronofy.com/developers/ui-elements/",
-            },
-        };
-
-        logConstructor("error", "ELEMENT_NAME", callback);
-        const log = logConstructor("error", "ELEMENT_NAME", callback);
-
-        log.error("TEST MESSAGE");
-
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(callback).toHaveBeenCalledTimes(1);
-        expect(callback).toHaveBeenCalledWith(expectedNotification);
-    });
-
-    it("calls provided callback with extra options", () => {
-        const callback = jest.fn();
-        const expectedNotification = {
-            notification: {
-                element: "ELEMENT_NAME",
-                errors: "ERRORS_OBJECT",
-                message: "TEST MESSAGE",
-                type: "error",
-                url: "https://docs.cronofy.com/developers/ui-elements/TEST",
-            },
-        };
-
-        logConstructor("error", "ELEMENT_NAME", callback);
-        const log = logConstructor("error", "ELEMENT_NAME", callback);
-
-        log.error("TEST MESSAGE", {
-            docsSlug: "TEST",
-            errorObject: "ERRORS_OBJECT",
-            unwanted: "THING",
-        });
-
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(callback).toHaveBeenCalledTimes(1);
-        expect(callback).toHaveBeenCalledWith(expectedNotification);
-    });
-
-    it("correctly builds log notification", () => {
-        const notification = buildLogNotification("TYPE", "ELEMENT", "MESSAGE");
-        expect(typeof notification.notification).toBe("object");
-        expect(notification.notification.message).toEqual("MESSAGE");
-        expect(notification.notification.type).toEqual("TYPE");
-        expect(notification.notification.element).toEqual("ELEMENT");
-        expect(notification.notification.errors).toEqual({});
-    });
-
-    it("correctly builds log notification with a URL slug", () => {
-        const notificationWithUrlSlug = buildLogNotification("TYPE", "ELEMENT", "MESSAGE", "SLUG");
-        expect(typeof notificationWithUrlSlug.notification).toBe("object");
-        expect(notificationWithUrlSlug.notification.message).toEqual("MESSAGE");
-        expect(notificationWithUrlSlug.notification.type).toEqual("TYPE");
-        expect(notificationWithUrlSlug.notification.element).toEqual("ELEMENT");
-        expect(notificationWithUrlSlug.notification.url).toEqual(
-            "https://docs.cronofy.com/developers/ui-elements/SLUG"
-        );
-    });
-
-    it("correctly builds log notification with an errors object", () => {
-        const notificationWithUrlSlug = buildLogNotification("TYPE", "ELEMENT", "MESSAGE", "SLUG", {
-            error_1: "ERROR_1",
-            error_2: "ERROR_2",
-        });
-        expect(typeof notificationWithUrlSlug.notification).toBe("object");
-        expect(notificationWithUrlSlug.notification.message).toEqual("MESSAGE");
-        expect(notificationWithUrlSlug.notification.type).toEqual("TYPE");
-        expect(notificationWithUrlSlug.notification.element).toEqual("ELEMENT");
-        expect(notificationWithUrlSlug.notification.url).toEqual(
-            "https://docs.cronofy.com/developers/ui-elements/SLUG"
-        );
-        expect(typeof notificationWithUrlSlug.notification.errors).toBe("object");
-        expect(Object.keys(notificationWithUrlSlug.notification.errors).length).toEqual(2);
-        expect(notificationWithUrlSlug.notification.errors.error_1).toEqual("ERROR_1");
-    });
-});

package/tests/mocks/i18n.js

@@ -1,3 +0,0 @@
-export const i18n = {
-    t: value => value,
-};

package/tests/mocks/theme.js

@@ -1,3 +0,0 @@
-import { parseStyleOptions } from "../../src/js/helpers/theming";
-
-export const theme = name => parseStyleOptions({}, name);

package/tests/setupJest.js

@@ -1,8 +0,0 @@
-import "core-js/stable";
-import "regenerator-runtime/runtime";
-import "@testing-library/jest-dom";
-
-import { enableFetchMocks } from "jest-fetch-mock";
-enableFetchMocks();
-
-global.moment = jest.requireActual("moment-timezone").tz.setDefault("Etc/UTC");