cronofy-elements 1.48.2 → 1.49.2

package/tests/i18n.test.js

@@ -1,255 +0,0 @@
-import * as i18n from "../src/js/helpers/i18n";
-import moment from "moment";
-
-describe("i18n", () => {
-    // getNavigatorLanguage
-    it("extracts the locale from the navigator", () => {
-        // gets the first locale if array is set
-        expect(i18n.getNavigatorLanguage({ languages: ["en"] })).toEqual("en");
-        // ...otherwise checks userLanguage
-        expect(i18n.getNavigatorLanguage({ userLanguage: "en" })).toEqual("en");
-        // ...otherwise checks language
-        expect(i18n.getNavigatorLanguage({ language: "en" })).toEqual("en");
-        // ...otherwise checks browserLanguage
-        expect(i18n.getNavigatorLanguage({ browserLanguage: "en" })).toEqual("en");
-        // falls back to "en"
-        expect(i18n.getNavigatorLanguage(false)).toEqual("en");
-    });
-
-    // i18n
-    it("picks the correct phrase by slug and locale", () => {
-        const testPhrases = {
-            en: {
-                core: { test: "Testing" },
-                alternate_context: {
-                    test: "Alternate test",
-                    extra: "An extra thing",
-                },
-            },
-            de: {
-                core: { test: "Testen" },
-                alternate_context: {
-                    extra: "Eine extra Sache",
-                },
-            },
-        };
-
-        const english = i18n.i18n("core", "test", "en", testPhrases);
-        expect(english).toEqual("Testing");
-
-        const german = i18n.i18n("core", "test", "de", testPhrases);
-        expect(german).toEqual("Testen");
-
-        const alternateContext = i18n.i18n("alternate_context", "extra", "en", testPhrases);
-        expect(alternateContext).toEqual("An extra thing");
-
-        const alternateContextDe = i18n.i18n("alternate_context", "extra", "de", testPhrases);
-        expect(alternateContextDe).toEqual("Eine extra Sache");
-    });
-
-    it("handles missing locales without breaking", () => {
-        const testPhrases = {
-            en: {
-                core: { test: "Testing" },
-                alternate_context: {
-                    test: "Alternate test",
-                    extra: "An extra thing",
-                },
-            },
-            de: {
-                core: { test: "Testen" },
-                alternate_context: {
-                    extra: "Eine extra Sache",
-                },
-            },
-        };
-
-        const context = "core";
-
-        const noLocale = i18n.i18n(context, "test", "gibberish", testPhrases);
-        expect(noLocale).toEqual("Testing");
-    });
-
-    it("handles missing context without breaking", () => {
-        const testPhrases = {
-            en: {
-                core: { test: "Testing" },
-                alternate_context: {
-                    test: "Alternate test",
-                    extra: "An extra thing",
-                },
-            },
-            de: {
-                core: { test: "Testen" },
-                alternate_context: {
-                    extra: "Eine extra Sache",
-                },
-            },
-        };
-
-        const alternateContext = i18n.i18n("alternate_context", "test", "en", testPhrases);
-        expect(alternateContext).toEqual("Alternate test");
-
-        const alternateContextDe = i18n.i18n("missing_context", "test", "de", testPhrases);
-        expect(alternateContextDe).toEqual("Testen");
-    });
-
-    it("handles missing phrases without breaking", () => {
-        // If there's no translation found, i18n() will output a `warn`.
-        // We're mocking that here for 2 reasons:
-        // 1. Keep the test's terminal output clean.
-        // 2. Test if the warn has been called (without having to test a native browser function).
-        console.warn = jest.fn();
-
-        const testPhrases = {
-            en: {
-                core: { test: "Testing" },
-                alternate_context: {
-                    test: "Alternate test",
-                    extra: "An extra thing",
-                },
-            },
-            de: {
-                core: { test: "Testen" },
-                alternate_context: {
-                    extra: "Eine extra Sache",
-                },
-            },
-        };
-        const alternateContextDe2 = i18n.i18n(
-            "alternate_context",
-            "this_slug_does_not_exist",
-            "de",
-            testPhrases
-        );
-        expect(alternateContextDe2).toEqual("This slug does not exist");
-        expect(console.warn).toHaveBeenCalledTimes(1);
-
-        const alternateContextFr = i18n.i18n(
-            "alternate_context",
-            "this_slug_does_not_exist",
-            "fr",
-            testPhrases
-        );
-        expect(alternateContextFr).toEqual("This slug does not exist");
-        expect(console.warn).toHaveBeenCalledTimes(2);
-
-        const incorrectSlug = i18n.i18n("core", "this_slug_does_not_exist");
-        expect(incorrectSlug).toEqual("This slug does not exist");
-        expect(console.warn).toHaveBeenCalledTimes(3);
-    });
-
-    it("fallsback to the base language when the locale is a dialect without a translation", () => {
-        const testPhrases = {
-            en: {
-                core: { stairs: "stairs", choux_bun: "choux bun" },
-            },
-            "en-COCKNEY": {
-                core: { stairs: "apples and pears" },
-            },
-        };
-
-        const dialectExists = i18n.i18n("core", "stairs", "en-COCKNEY", testPhrases);
-        expect(dialectExists).toEqual("apples and pears");
-
-        const fallbackRequired = i18n.i18n("core", "choux_bun", "en-COCKNEY", testPhrases);
-        expect(fallbackRequired).toEqual("choux bun");
-    });
-});
-
-describe("i18n.dateToSlotStringWithoutTzShift", () => {
-    const testTime = moment("2021-08-12T10:00:00Z");
-
-    it("EN formats the time into a reasonable format", () => {
-        const translations = i18n.i18nConstructor({ locale: "en", tzid: "UTC" });
-
-        const formatted = translations.dateToSlotStringWithoutTzShift(testTime);
-        expect(formatted).toEqual("Thursday 12th August");
-    });
-
-    it("translates the elements in the EN format", () => {
-        const translations = i18n.i18nConstructor({ locale: "de", tzid: "UTC" });
-
-        const formatted = translations.dateToSlotStringWithoutTzShift(testTime);
-        expect(formatted).toEqual("Donnerstag 12. August");
-    });
-
-    describe("when constructed using some locale_modifiers for the current locale", () => {
-        it("returns the modified variant of the date format", () => {
-            const translations = i18n.i18nConstructor({
-                locale: "ja",
-                localeModifiers: { ja: { dates: "western" } },
-                tzid: "UTC",
-            });
-
-            const formatted = translations.dateToSlotStringWithoutTzShift(testTime);
-            expect(formatted).toEqual("2021年 8月 12日 (木)");
-        });
-    });
-
-    describe("when constructed using some locale_modifiers for another locale", () => {
-        it("returns the modified variant of the date format", () => {
-            const translations = i18n.i18nConstructor({
-                locale: "en",
-                localeModifiers: { ja: { dates: "western" } },
-                tzid: "UTC",
-            });
-
-            const formatted = translations.dateToSlotStringWithoutTzShift(testTime);
-            expect(formatted).toEqual("Thursday 12th August");
-        });
-    });
-
-    describe("when constructed with invalid locale_modifiers", () => {
-        it("returns a the default date format", () => {
-            const translations = i18n.i18nConstructor({
-                locale: "ja",
-                localeModifiers: { ja: { dates: "asterley" } },
-                tzid: "UTC",
-            });
-
-            const formatted = translations.dateToSlotStringWithoutTzShift(testTime);
-            expect(formatted).toEqual("木曜日 12日 8月");
-        });
-    });
-});
-
-describe("i18n.timeToSlotString", () => {
-    const testTime = moment("2021-08-12T15:00:00Z");
-
-    describe("in a locale that favours 12 hour time", () => {
-        it("returns a the default date format", () => {
-            const translations = i18n.i18nConstructor({
-                locale: "en-US",
-                tzid: "UTC",
-            });
-
-            const formatted = translations.timeToSlotString(testTime);
-            expect(formatted).toEqual("3:00PM");
-        });
-    });
-
-    describe("in a locale that favours 24 hour time", () => {
-        it("returns a the default date format", () => {
-            const translations = i18n.i18nConstructor({
-                locale: "fr",
-                tzid: "UTC",
-            });
-
-            const formatted = translations.timeToSlotString(testTime);
-            expect(formatted).toEqual("15:00");
-        });
-    });
-
-    describe("in timezone offset from UTC", () => {
-        it("returns a the default date format", () => {
-            const translations = i18n.i18nConstructor({
-                locale: "en-US",
-                tzid: "America/Chicago",
-            });
-
-            const formatted = translations.timeToSlotString(testTime);
-            expect(formatted).toEqual("10:00AM");
-        });
-    });
-});

package/tests/init.Agenda.test.js

@@ -1,122 +0,0 @@
-import { parseAgendaOptions } from "../src/js/helpers/init.Agenda";
-
-// 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 Agenda options", () => {
-    it("works when all options are declared", () => {
-        const input = {
-            data_center: "de",
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const expectedOutput = {
-            config: { logs: "warn", mode: "default" },
-            data_center: "de",
-            domains: {
-                apiDomain: "https://api-de.cronofy.com",
-                appDomain: "https://app-de.cronofy.com",
-            },
-            target: "TARGET",
-            token: "TOKEN",
-        };
-        const result = parseAgendaOptions(input);
-        expect(result.data_center).toEqual(expectedOutput.data_center);
-        expect(result.domains).toEqual(expectedOutput.domains);
-        expect(result.target).toEqual(expectedOutput.target);
-        expect(result.token).toEqual(expectedOutput.token);
-        expect(result.config).toEqual(expectedOutput.config);
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-
-    it("supports valid modes", () => {
-        const input = {
-            config: { mode: "free_busy" },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-        const expectedConfig = { logs: "warn", mode: "free_busy" };
-
-        const result = parseAgendaOptions(input);
-        expect(result.config).toEqual(expectedConfig);
-        expect(result.config.mode).toEqual("free_busy");
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-
-    it("errors when given an invalid mode", () => {
-        const input = {
-            config: { mode: "INVALID_MODE" },
-            target_id: "TARGET",
-            element_token: "TOKEN",
-        };
-
-        const result = parseAgendaOptions(input);
-        expect(result).toEqual(false);
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-
-    it("fails if there is no token declared", () => {
-        expect(parseAgendaOptions({ target_id: "TARGET" })).toEqual(false);
-        expect(console.error).toHaveBeenCalledTimes(1);
-    });
-
-    it("continues if there is no token declared, but we're in demo mode", () => {
-        const expectedOutput = {
-            demo: true,
-            domains: {
-                apiDomain: "https://api.cronofy.com",
-                appDomain: "https://app.cronofy.com",
-            },
-            target: "cronofy-element-agenda",
-            token: false,
-        };
-        const result = parseAgendaOptions({ demo: true });
-        expect(result.demo).toEqual(expectedOutput.demo);
-        expect(result.token).toEqual(expectedOutput.token);
-        expect(console.warn).toHaveBeenCalledTimes(2);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default target if there is no target option", () => {
-        const expectedOutput = {
-            target: "cronofy-element-agenda",
-            token: "TOKEN",
-            domains: {
-                apiDomain: "https://api.cronofy.com",
-                appDomain: "https://app.cronofy.com",
-            },
-        };
-        const result = parseAgendaOptions({ element_token: "TOKEN" });
-        expect(result.target).toEqual(expectedOutput.target);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default api_domain if there is no api_domain option", () => {
-        const expectedOutput = {
-            domains: {
-                apiDomain: "https://api.cronofy.com",
-                appDomain: "https://app.cronofy.com",
-            },
-            target: "TARGET",
-            token: "TOKEN",
-        };
-        const result = parseAgendaOptions({
-            element_token: "TOKEN",
-            target_id: "TARGET",
-        });
-        expect(result.domains).toEqual(expectedOutput.domains);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-});

package/tests/init.AvailabilityRules.test.js

@@ -1,279 +0,0 @@
-import moment from "moment-timezone";
-import { parseAvailabilityRulesOptions } from "../src/js/helpers/init.AvailabilityRules";
-
-// 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 AvailabilityRules options", () => {
-    const sniffedTimezone = moment.tz.guess();
-
-    it("works when all options are declared", () => {
-        const input = {
-            config: {
-                logs: "info",
-                week_start_day: "monday",
-                default_weekly_periods: [
-                    {
-                        day: "monday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "tuesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "wednesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                ],
-                auto_create_rules: false,
-            },
-            data_center: "de",
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            availability_rule_id: "RULE_ID",
-            tzid: sniffedTimezone,
-        };
-        const expectedOutput = {
-            availability_rule_id: "RULE_ID",
-            config: {
-                logs: "info",
-                startDay: "monday",
-                defaultWeeklyPeriods: [
-                    {
-                        day: "monday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "tuesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                    {
-                        day: "wednesday",
-                        end_time: "17:00",
-                        start_time: "09:00",
-                    },
-                ],
-                autoCreateRulesMode: false,
-                keyboardSupport: false,
-            },
-            data_center: "de",
-            domains: {
-                apiDomain: "https://api-de.cronofy.com",
-                appDomain: "https://app-de.cronofy.com",
-            },
-            error: false,
-            target: "TARGET",
-            token: "TOKEN",
-            tzid: sniffedTimezone,
-        };
-        const result = parseAvailabilityRulesOptions(input);
-        expect(result.availability_rule_id).toEqual(expectedOutput.availability_rule_id);
-        expect(result.config).toEqual(expectedOutput.config);
-        expect(result.data_center).toEqual(expectedOutput.data_center);
-        expect(result.domains).toEqual(expectedOutput.domains);
-        expect(result.error).toEqual(expectedOutput.error);
-        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("shows a warning if there is no availability_rule_id present when all other options are declared", () => {
-        const input = {
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            tzid: sniffedTimezone,
-        };
-        parseAvailabilityRulesOptions(input);
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-    });
-
-    it("applies the default weekly periods when there is no default declared by the user", () => {
-        const input = {
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            availability_rule_id: "RULE_ID",
-            tzid: sniffedTimezone,
-            config: {},
-        };
-        const expectedOutput = {
-            defaultWeeklyPeriods: [
-                {
-                    day: "monday",
-                    end_time: "17:00",
-                    start_time: "09:00",
-                },
-                {
-                    day: "tuesday",
-                    end_time: "17:00",
-                    start_time: "09:00",
-                },
-                {
-                    day: "wednesday",
-                    end_time: "17:00",
-                    start_time: "09:00",
-                },
-                {
-                    day: "thursday",
-                    end_time: "17:00",
-                    start_time: "09:00",
-                },
-                {
-                    day: "friday",
-                    end_time: "17:00",
-                    start_time: "09:00",
-                },
-            ],
-        };
-        const result = parseAvailabilityRulesOptions(input);
-        expect(result.config.defaultWeeklyPeriods).toEqual(expectedOutput.defaultWeeklyPeriods);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("fails if there is no token declared", () => {
-        expect(parseAvailabilityRulesOptions()).toEqual(false);
-        expect(console.error).toHaveBeenCalledTimes(1);
-    });
-
-    it("continues if there is no token declared, but we're in demo mode", () => {
-        const expectedOutput = {
-            availability_rule_id: "RULE_ID",
-            config: {},
-            demo: true,
-            domains: {
-                apiDomain: "https://api.cronofy.com",
-                appDomain: "https://app.cronofy.com",
-            },
-            error: false,
-            target: "cronofy-element-availability-rules",
-            token: false,
-            tzid: sniffedTimezone,
-        };
-        const result = parseAvailabilityRulesOptions({
-            demo: true,
-            availability_rule_id: "RULE_ID",
-            tzid: sniffedTimezone,
-        });
-        expect(result.demo).toEqual(expectedOutput.demo);
-        expect(result.token).toEqual(expectedOutput.token);
-        expect(console.warn).toHaveBeenCalledTimes(2);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default target if there is no target option", () => {
-        const expectedOutput = {
-            availability_rule_id: "RULE_ID",
-            config: {},
-            domains: {
-                apiDomain: "https://api.cronofy.com",
-                appDomain: "https://app.cronofy.com",
-            },
-            error: false,
-            target: "cronofy-element-availability-rules",
-            token: "TOKEN",
-            tzid: sniffedTimezone,
-        };
-        const result = parseAvailabilityRulesOptions({
-            element_token: "TOKEN",
-            availability_rule_id: "RULE_ID",
-            tzid: sniffedTimezone,
-        });
-        expect(result.target).toEqual(expectedOutput.target);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("applies the default domains if there is no data_center option", () => {
-        const expectedOutput = {
-            availability_rule_id: "RULE_ID",
-            config: {},
-            domains: {
-                apiDomain: "https://api.cronofy.com",
-                appDomain: "https://app.cronofy.com",
-            },
-            error: false,
-            target: "TARGET",
-            token: "TOKEN",
-            tzid: sniffedTimezone,
-        };
-        const result = parseAvailabilityRulesOptions({
-            availability_rule_id: "RULE_ID",
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            tzid: sniffedTimezone,
-        });
-        expect(result.domains).toEqual(expectedOutput.domains);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("creates correct domains if there is a data_center option", () => {
-        const expectedOutput = {
-            availability_rule_id: "RULE_ID",
-            config: {},
-            data_center: "de",
-            domains: {
-                apiDomain: "https://api-de.cronofy.com",
-                appDomain: "https://app-de.cronofy.com",
-            },
-            error: false,
-            target: "TARGET",
-            token: "TOKEN",
-            tzid: sniffedTimezone,
-        };
-        const result = parseAvailabilityRulesOptions({
-            availability_rule_id: "RULE_ID",
-            data_center: "de",
-            element_token: "TOKEN",
-            target_id: "TARGET",
-            tzid: sniffedTimezone,
-        });
-        expect(result.domains).toEqual(expectedOutput.domains);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(console.error).toHaveBeenCalledTimes(0);
-    });
-
-    it("correctly parses the keyboard_support option", () => {
-        const input = {
-            target_id: "TARGET",
-            element_token: "TOKEN",
-            availability_rule_id: "RULE_ID",
-            config: {
-                keyboard_support: "basic",
-            },
-        };
-        const expectedOutput = {
-            config: {
-                keyboardSupport: "basic",
-            },
-        };
-        const result = parseAvailabilityRulesOptions(input);
-        expect(result.config.keyboardSupport).toEqual(expectedOutput.config.keyboardSupport);
-    });
-
-    it("shows an error if there is an invalid keyboard_support option present", () => {
-        const input = {
-            config: {
-                keyboard_support: "invalid-option",
-            },
-        };
-        parseAvailabilityRulesOptions(input);
-        expect(console.error).toHaveBeenCalledTimes(1);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-});