cronofy-elements 1.48.1 → 1.49.1

package/tests/events.test.js

@@ -1,472 +0,0 @@
-import * as datetimes from "../src/js/helpers/events";
-import moment from "moment";
-
-describe("Events helpers", () => {
-    // isAllDayEvent
-    it("recognises an all-day event", () => {
-        const allDay = ["2018-09-20", "2018-09-21"];
-        const timed = ["2018-09-20T09:00:00Z", "2018-09-20T17:00:00Z"];
-        expect(datetimes.isAllDayEvent(...allDay)).toBe(true);
-        expect(datetimes.isAllDayEvent(...timed)).toBe(false);
-    });
-
-    // checkISO8601
-    it("check if a string matches ISO8601 format", () => {
-        const ISO8601String = "2018-09-20";
-        const NotISO8601String = "2018-09-20T17:00:00Z";
-        expect(datetimes.checkISO8601(ISO8601String)).toBe(true);
-        expect(datetimes.checkISO8601(NotISO8601String)).toBe(false);
-        expect(datetimes.checkISO8601("")).toBe(false);
-    });
-
-    // dayNumbers
-    it("calculates day numbers", () => {
-        const multiDayEvent = datetimes.dayNumbers(
-            moment("2018-09-20"),
-            moment("2018-09-24"),
-            moment("2018-09-22")
-        );
-        // Total days of event
-        expect(multiDayEvent.days).toEqual(4);
-        // Current day number
-        expect(multiDayEvent.day).toEqual(3);
-
-        const singleDayEvent = datetimes.dayNumbers(
-            moment("2018-09-20"),
-            moment("2018-09-21"),
-            moment("2018-09-20")
-        );
-        // Total days of event
-        expect(singleDayEvent.days).toEqual(1);
-        // Current day number
-        expect(singleDayEvent.day).toEqual(1);
-    });
-
-    // dayNumbersString
-    it("writes the day info to a sentence", () => {
-        const multiDayEvent = [moment("2018-09-20"), moment("2018-09-24"), moment("2018-09-22")];
-        expect(datetimes.dayNumbersString(...multiDayEvent)).toEqual(" - 3/4");
-
-        const singleDayEvent = [moment("2018-09-20"), moment("2018-09-21"), moment("2018-09-20")];
-        expect(datetimes.dayNumbersString(...singleDayEvent)).toEqual("");
-    });
-
-    // getMultiDayStatus
-    // returns 0 if not a multi-day event, 1 if the first day, 2 if the last day, 3 if a middle day
-    it("works out if today is the start|end|middle of an event", () => {
-        const eventStart = ["2018-09-20", "2018-09-24", "2018-09-20"];
-        const eventEnd = ["2018-09-20", "2018-09-24", "2018-09-23"];
-        const eventMid = ["2018-09-20", "2018-09-24", "2018-09-22"];
-        const singleDay = ["2018-09-20", "2018-09-21", "2018-09-20"];
-        const timedEvent = ["2018-10-01T09:00:00Z", "2018-10-01T10:00:00Z", "2018-10-01"];
-        expect(datetimes.getMultiDayStatus(...eventStart)).toEqual(1);
-        expect(datetimes.getMultiDayStatus(...eventEnd)).toEqual(2);
-        expect(datetimes.getMultiDayStatus(...eventMid)).toEqual(3);
-        expect(datetimes.getMultiDayStatus(...singleDay)).toEqual(0);
-        expect(datetimes.getMultiDayStatus(...timedEvent)).toEqual(0);
-    });
-
-    // checkDirection
-    it("calculates direction to scroll", () => {
-        const backwards = [moment("2018-09-20"), moment("2018-10-10")];
-        const forwards = [moment("2018-09-20"), moment("2018-07-18")];
-        expect(datetimes.checkDirection(...backwards)).toEqual("backwards");
-        expect(datetimes.checkDirection(...forwards)).toEqual("forwards");
-    });
-
-    // eventDates
-    it("calculates the dates that a multi-day event covers", () => {
-        const exampleMultiDayEvent = {
-            event_uid: "EXAMPLE_ID",
-            start: "2018-09-23",
-            end: "2018-09-26",
-        };
-        const multiDayDates = datetimes.eventDates(exampleMultiDayEvent);
-        // It sets a key for each day
-        expect(Object.keys(multiDayDates).length).toEqual(3);
-        // the day-keys have only one sub key (event_uid)
-        expect(Object.keys(multiDayDates["2018-09-23"]).length).toEqual(1);
-        expect(Object.keys(multiDayDates["2018-09-24"]).length).toEqual(1);
-        expect(Object.keys(multiDayDates["2018-09-25"]).length).toEqual(1);
-        // there is no day-key set for the day *after* the event
-        expect(typeof multiDayDates["2018-09-26"]).toEqual("undefined");
-        // the day-keys have the correct event_uid set as the sub key
-        expect(multiDayDates["2018-09-23"]["EXAMPLE_ID"]).toBe(true);
-        expect(multiDayDates["2018-09-24"]["EXAMPLE_ID"]).toBe(true);
-        expect(multiDayDates["2018-09-25"]["EXAMPLE_ID"]).toBe(true);
-    });
-
-    it("calculates the dates that a single-day all-day event covers", () => {
-        const exampleOneDayEvent = {
-            event_uid: "EXAMPLE_ID",
-            start: "2018-09-24",
-            end: "2018-09-25",
-        };
-        const allDayDates = datetimes.eventDates(exampleOneDayEvent);
-        expect(Object.keys(allDayDates).length).toEqual(1);
-        expect(Object.keys(allDayDates["2018-09-24"]).length).toEqual(1);
-        expect(allDayDates["2018-09-24"]["EXAMPLE_ID"]).toBe(true);
-    });
-
-    it("calculates the dates that a timed event covers", () => {
-        const exampleTimedEvent = {
-            event_uid: "EXAMPLE_ID",
-            start: "2018-10-01T09:00:00Z",
-            end: "2018-10-01T10:00:00Z",
-        };
-        const timedDates = datetimes.eventDates(exampleTimedEvent);
-        expect(Object.keys(timedDates).length).toEqual(1);
-        expect(Object.keys(timedDates["2018-10-01"]).length).toEqual(1);
-        expect(timedDates["2018-10-01"]["EXAMPLE_ID"]).toBe(true);
-    });
-
-    // getDayRange
-    it("adds new date range to existing state object", () => {
-        // Works on first load
-        const daysFromNothing = datetimes.getDayRange("2018-09-07", 7);
-        expect(Object.keys(daysFromNothing).length).toEqual(15);
-
-        // Works with existing state
-        const existingDays = {
-            "2018-09-24": {},
-            "2018-09-25": {},
-            "2018-09-26": {},
-            "2018-09-27": {},
-            "2018-09-28": {},
-            "2018-09-29": {},
-            "2018-09-30": {},
-            "2018-10-01": {},
-            "2018-10-02": {},
-            "2018-10-03": {},
-            "2018-10-04": {},
-            "2018-10-05": {},
-            "2018-10-06": {},
-            "2018-10-07": {},
-            "2018-10-08": {},
-        };
-        const daysUpdated = datetimes.getDayRange("2018-10-09", 7, existingDays);
-        expect(Object.keys(daysUpdated).length).toEqual(23);
-    });
-
-    // setEventDayIDs
-    it("adds event IDs to relevant dates in daysObject", () => {
-        const daysObject = {
-            "2018-09-23": {},
-            "2018-09-24": {},
-            "2018-09-25": {},
-            "2018-09-26": {},
-            "2018-09-27": {},
-            "2018-09-28": {},
-            "2018-09-29": {},
-            "2018-09-30": {},
-            "2018-10-01": {},
-            "2018-10-02": {},
-            "2018-10-03": {},
-            "2018-10-04": {},
-            "2018-10-05": {},
-            "2018-10-06": {},
-            "2018-10-07": {},
-        };
-        const events = [
-            {
-                event_uid: "EXAMPLE_ID_1",
-                start: "2018-09-23",
-                end: "2018-09-26",
-            },
-            {
-                event_uid: "EXAMPLE_ID_2",
-                start: "2018-09-24",
-                end: "2018-09-25",
-            },
-            {
-                event_uid: "EXAMPLE_ID_3",
-                start: "2018-10-01T09:00:00Z",
-                end: "2018-10-01T10:00:00Z",
-            },
-        ];
-        const mockEventDates = jest.fn(event => {
-            switch (event.event_uid) {
-                case "EXAMPLE_ID_1":
-                    return {
-                        "2018-09-23": { EXAMPLE_ID_1: true },
-                        "2018-09-24": { EXAMPLE_ID_1: true },
-                        "2018-09-25": { EXAMPLE_ID_1: true },
-                    };
-                    break;
-                case "EXAMPLE_ID_2":
-                    return { "2018-09-24": { EXAMPLE_ID_2: true } };
-                    break;
-                case "EXAMPLE_ID_3":
-                    return { "2018-10-01": { EXAMPLE_ID_3: true } };
-                    break;
-                default:
-                    return {};
-            }
-        });
-
-        const daysWithIDs = datetimes.setEventDayIDs(events, daysObject, mockEventDates);
-        expect(Object.keys(daysWithIDs).length).toEqual(15);
-        expect(Object.keys(daysWithIDs["2018-09-23"]).length).toEqual(1);
-        expect(Object.keys(daysWithIDs["2018-09-24"]).length).toEqual(2);
-        expect(Object.keys(daysWithIDs["2018-09-26"]).length).toEqual(0);
-    });
-
-    // parseEvents
-    it("adds events to events-object, using uid as the key", () => {
-        const newEventsArray = [
-            {
-                event_uid: "EXAMPLE_ID_1",
-                start: "2018-09-23",
-                end: "2018-09-26",
-            },
-            {
-                event_uid: "EXAMPLE_ID_2",
-                start: "2018-09-24",
-                end: "2018-09-25",
-            },
-            {
-                event_uid: "EXAMPLE_ID_3",
-                start: "2018-10-01T09:00:00Z",
-                end: "2018-10-01T10:00:00Z",
-            },
-        ];
-        const existingEventsObject = {};
-        const updatedEventsObject = datetimes.parseEventsByID(newEventsArray);
-        // Adds the correct number of events
-        expect(Object.keys(updatedEventsObject).length).toEqual(3);
-        // Uses the correct keys
-        expect(Object.keys(updatedEventsObject["EXAMPLE_ID_1"]).length).toEqual(3);
-        expect(updatedEventsObject["EXAMPLE_ID_1"]).toEqual(newEventsArray[0]);
-        expect(updatedEventsObject["EXAMPLE_ID_2"]).toEqual(newEventsArray[1]);
-        expect(updatedEventsObject["EXAMPLE_ID_3"]).toEqual(newEventsArray[2]);
-    });
-
-    // calculateLimit
-    it("checks if navigation passes the limits", () => {
-        const sameDay = datetimes.calculateLimit("2018-09-24", "2018-09-24");
-        expect(sameDay).toEqual(0);
-
-        const futureWithinLimits = datetimes.calculateLimit("2018-10-24", "2018-09-24");
-        expect(futureWithinLimits).toEqual(0);
-
-        const futureBeyondLimits = datetimes.calculateLimit("2019-10-24", "2018-09-24");
-        expect(futureBeyondLimits).toEqual(1);
-
-        const pastWithinLimits = datetimes.calculateLimit("2018-09-20", "2018-09-24");
-        expect(pastWithinLimits).toEqual(0);
-
-        const pastBeyondLimits = datetimes.calculateLimit("2018-08-24", "2018-09-24");
-        expect(pastBeyondLimits).toEqual(-1);
-    });
-
-    // sortEventsByType
-    it("sorts events by type", () => {
-        const mixedEvents = [
-            {
-                summary: "Conference",
-                start: "2018-11-05",
-                end: "2018-11-06",
-            },
-            {
-                summary: "Client call",
-                start: "2018-11-05T09:00:00Z",
-                end: "2018-11-05T10:00:00Z",
-            },
-            {
-                summary: "Another all-day event",
-                start: "2018-11-05",
-                end: "2018-11-06",
-            },
-            {
-                summary: "Meeting",
-                start: "2018-11-05T12:00:00Z",
-                end: "2018-11-05T13:00:00Z",
-            },
-        ];
-        const sortedMixedEvents = datetimes.sortEventsByType(mixedEvents);
-        expect(sortedMixedEvents.allDay.length).toEqual(2);
-        expect(sortedMixedEvents.allDay[1]).toEqual(mixedEvents[2]);
-        expect(sortedMixedEvents.timed.length).toEqual(2);
-        expect(sortedMixedEvents.timed[0]).toEqual(mixedEvents[1]);
-
-        const noTimedEvents = [
-            {
-                summary: "Conference",
-                start: "2018-11-05",
-                end: "2018-11-06",
-            },
-            {
-                summary: "Another all-day event",
-                start: "2018-11-05",
-                end: "2018-11-06",
-            },
-        ];
-        const sortedEvents = datetimes.sortEventsByType(noTimedEvents);
-        expect(sortedEvents.allDay.length).toEqual(2);
-        expect(sortedEvents.allDay[1]).toEqual(noTimedEvents[1]);
-        expect(sortedEvents.timed.length).toEqual(0);
-
-        const noAllDayEvents = [
-            {
-                summary: "Client call",
-                start: "2018-11-05T09:00:00Z",
-                end: "2018-11-05T10:00:00Z",
-            },
-            {
-                summary: "Meeting",
-                start: "2018-11-05T12:00:00Z",
-                end: "2018-11-05T13:00:00Z",
-            },
-        ];
-        const sortedNoAllDayEvents = datetimes.sortEventsByType(noAllDayEvents);
-        expect(sortedNoAllDayEvents.allDay.length).toEqual(0);
-        expect(sortedNoAllDayEvents.timed.length).toEqual(2);
-        expect(sortedNoAllDayEvents.timed[1]).toEqual(noAllDayEvents[1]);
-
-        const MuddledEvents = [
-            {
-                summary: "Another all-day event",
-                start: "2018-11-05",
-                end: "2018-11-06",
-            },
-            {
-                summary: "Meeting",
-                start: "2018-11-05T12:00:00Z",
-                end: "2018-11-05T13:00:00Z",
-            },
-            {
-                summary: "Conference",
-                start: "2018-11-05",
-                end: "2018-11-06",
-            },
-            {
-                summary: "Client call",
-                start: "2018-11-05T09:00:00Z",
-                end: "2018-11-05T10:00:00Z",
-            },
-            {
-                summary: "Client call #2",
-                start: "2018-11-05T09:00:00Z",
-                end: "2018-11-05T10:00:00Z",
-            },
-            {
-                summary: "Client call",
-                start: "2018-11-05T11:00:00Z",
-                end: "2018-11-05T11:30:00Z",
-            },
-        ];
-        const sortedMuddledEvents = datetimes.sortEventsByType(MuddledEvents);
-        expect(sortedMuddledEvents.allDay.length).toEqual(2);
-        expect(sortedMuddledEvents.timed.length).toEqual(4);
-        expect(sortedMuddledEvents.timed[0]).toEqual(MuddledEvents[3]);
-    });
-
-    // getEventByID
-    it("gets event by ID", () => {
-        const events = [
-            {
-                calendar_id: "cal_0123456",
-                event_uid: "evt_0123456",
-                start: "2018-11-05T09:00:00Z",
-                end: "2018-11-05T17:00:00Z",
-            },
-            {
-                calendar_id: "cal_0123",
-                event_uid: "evt_0456",
-                start: "2018-11-05T09:00:00Z",
-                end: "2018-11-05T10:00:00Z",
-            },
-            {
-                calendar_id: "cal_3456",
-                event_uid: "evt_0123",
-                start: "2018-11-05T10:00:00Z",
-                end: "2018-11-05T12:00:00Z",
-            },
-            {
-                calendar_id: "cal_01234561234",
-                event_uid: "evt_01234561234",
-                start: "2018-11-05T12:00:00Z",
-                end: "2018-11-05T13:00:00Z",
-            },
-        ];
-
-        const targetEvent = {
-            calendar_id: "cal_3456",
-            event_uid: "evt_0123",
-            start: "2018-11-05T10:00:00Z",
-            end: "2018-11-05T12:00:00Z",
-        };
-
-        expect(datetimes.getEventByID("evt_0123", events)).toEqual(targetEvent);
-    });
-
-    // getCalColor
-    it("gets calendar color", () => {
-        const cals = [
-            {
-                name: "NAME THREE",
-                id: "cal_654_098",
-                color: 872,
-            },
-            {
-                name: "NAME",
-                id: "cal_123456",
-                color: 0,
-            },
-            {
-                name: "NAME TWO",
-                id: "cal_654321",
-                color: 1,
-            },
-        ];
-        expect(datetimes.getCalColor("cal_654321", cals)).toEqual(1);
-        expect(datetimes.getCalColor("cal_654_098", cals)).toEqual(872);
-    });
-
-    // parseDirection
-    it("parses a direction into a valid string", () => {
-        expect(datetimes.parseDirection()).toEqual("forwards");
-        expect(datetimes.parseDirection("gobbledegook")).toEqual("forwards");
-        expect(datetimes.parseDirection("forward")).toEqual("forwards");
-        expect(datetimes.parseDirection("forwards")).toEqual("forwards");
-
-        expect(datetimes.parseDirection("up")).toEqual("upwards");
-        expect(datetimes.parseDirection("upward")).toEqual("upwards");
-        expect(datetimes.parseDirection("upwards")).toEqual("upwards");
-
-        expect(datetimes.parseDirection("down")).toEqual("downwards");
-        expect(datetimes.parseDirection("downward")).toEqual("downwards");
-        expect(datetimes.parseDirection("downwards")).toEqual("downwards");
-
-        expect(datetimes.parseDirection("back")).toEqual("backwards");
-        expect(datetimes.parseDirection("backward")).toEqual("backwards");
-        expect(datetimes.parseDirection("backwards")).toEqual("backwards");
-    });
-
-    // getCalendarsFromEvents
-    it("extracts a list of unique calendars from an array of events", () => {
-        const events = [
-            {
-                calendar_id: "1",
-            },
-            {
-                calendar_id: "1",
-            },
-            {
-                calendar_id: "asfg",
-            },
-            {
-                calendar_id: "2",
-            },
-            {
-                calendar_id: "asfg",
-            },
-        ];
-        const calendars = [
-            { color: 0, id: "1" },
-            { color: 1, id: "asfg" },
-            { color: 2, id: "2" },
-        ];
-        expect(datetimes.getCalendarsFromEvents(events)).toEqual(calendars);
-    });
-});

package/tests/generator.test.js

@@ -1,74 +0,0 @@
-import { generateElementAPI } from "../src/js/helpers/generator";
-
-// The parsers rely on console warning and errors to
-// comunicate problems to the users
-console.error = jest.fn();
-console.warn = jest.fn();
-
-jest.mock("react-dom", () => ({
-    render: jest.fn(),
-}));
-
-beforeEach(() => {
-    console.error.mockClear();
-    console.warn.mockClear();
-    global.document.getElementById = jest.fn(() => true);
-});
-
-describe("Generating generic methods", () => {
-    it("Adds an update method", () => {
-        const renderer = jest.fn();
-        const parser = jest.fn(options => options);
-        const options = [renderer, {}, parser, "ELEMENT_NAME"];
-
-        const elementAPI = generateElementAPI(...options);
-
-        expect(renderer.mock.calls.length).toBe(1);
-        expect(typeof elementAPI.update).toBe("function");
-
-        elementAPI.update({});
-
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-        expect(renderer.mock.calls.length).toBe(2);
-    });
-
-    it("Update method fails with no params", () => {
-        const renderer = jest.fn();
-        const parser = jest.fn(options => options);
-        const options = [renderer, {}, parser, "ELEMENT_NAME"];
-
-        const elementAPI = generateElementAPI(...options);
-
-        expect(renderer.mock.calls.length).toBe(1);
-
-        elementAPI.update();
-
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(1);
-
-        expect(renderer.mock.calls.length).toBe(1);
-    });
-
-    it("Adds a refresh method", () => {
-        const renderer = jest.fn();
-        const parser = jest.fn(options => options);
-        const options = [renderer, {}, parser, "ELEMENT_NAME"];
-
-        const elementAPI = generateElementAPI(...options);
-
-        expect(renderer.mock.calls.length).toBe(1);
-        expect(typeof elementAPI.refresh).toBe("function");
-
-        elementAPI.refresh();
-
-        expect(renderer.mock.calls.length).toBe(2);
-
-        elementAPI.refresh();
-
-        expect(renderer.mock.calls.length).toBe(3);
-
-        expect(console.error).toHaveBeenCalledTimes(0);
-        expect(console.warn).toHaveBeenCalledTimes(0);
-    });
-});