@jobber/components-native 0.101.3 → 0.101.4

package/dist/src/Select/components/SelectInternalPicker/SelectInternalPicker.test.js

@@ -0,0 +1,72 @@
+import React from "react";
+import { fireEvent, render } from "@testing-library/react-native";
+import { View } from "react-native";
+import { SelectInternalPicker } from ".";
+import { Text } from "../../../Text";
+let Platform;
+beforeEach(() => {
+    Platform = require("react-native").Platform;
+    Object.defineProperty(Platform, "Version", { get: () => undefined });
+});
+function MockPicker() {
+    return React.createElement("MockPicker");
+}
+const MockPickerItem = () => React.createElement(React.Fragment, null);
+jest.mock("@react-native-picker/picker", () => ({ Picker: MockPicker }));
+MockPicker.Item = MockPickerItem;
+afterEach(() => {
+    jest.resetAllMocks();
+});
+const RCTPicker = "RCTATLPicker";
+const childText = "Click me";
+const handleChange = jest.fn();
+function setup(props) {
+    return render(React.createElement(View, { testID: "SelectInternalPicker" },
+        React.createElement(SelectInternalPicker, { onChange: handleChange, disabled: props === null || props === void 0 ? void 0 : props.disabled, options: [
+                { value: "1", label: "First option" },
+                { value: "2", label: "Second option" },
+            ] },
+            React.createElement(Text, null, childText))));
+}
+describe("SelectInternalPicker", () => {
+    it("fires the onChange", () => {
+        const screen = setup();
+        fireEvent.press(screen.getByText(childText));
+        const menu = screen
+            .getByTestId("SelectInternalPicker")
+            .findByType(MockPicker);
+        expect(menu).toBeDefined();
+        fireEvent(menu, "onChange", "1");
+        expect(handleChange).toHaveBeenCalledWith("1");
+    });
+    describe("iOS 13 and below fallback", () => {
+        it("renders the iOS 14 native menu picker", () => {
+            Platform.OS = "ios";
+            Object.defineProperty(Platform, "Version", { get: () => "14.1" });
+            const screen = setup();
+            const menu = screen
+                .getByTestId("SelectInternalPicker")
+                .findByType(RCTPicker);
+            expect(menu).toBeDefined();
+        });
+        it.each([
+            ["ios", "13.1"],
+            ["android", 100],
+        ])("renders the menu picker on %s", (os, version) => {
+            Platform.OS = os;
+            Object.defineProperty(Platform, "Version", { get: () => version });
+            const screen = setup();
+            fireEvent.press(screen.getByText(childText));
+            expect(screen.getByTestId("SelectInternalPicker").findByType(MockPicker)).toBeDefined();
+        });
+    });
+    describe("Disabled", () => {
+        it("should not render the picker", () => {
+            const screen = setup({ disabled: true });
+            const menu = screen
+                .getByTestId("SelectInternalPicker")
+                .findAllByType(RCTPicker);
+            expect(menu).toEqual([]);
+        });
+    });
+});

package/dist/src/StatusLabel/StatusLabel.test.js

@@ -0,0 +1,51 @@
+import React from "react";
+import { render } from "@testing-library/react-native";
+import { StatusLabel } from "./StatusLabel";
+describe("StatusLabel", () => {
+    describe("alignment", () => {
+        describe('when alignment prop set to default ("start")', () => {
+            it("should match snapshot", () => {
+                const view = render(React.createElement(StatusLabel, { text: "Start Aligned" })).toJSON();
+                expect(view).toMatchSnapshot();
+            });
+        });
+        describe('when alignment prop set to "end"', () => {
+            it("should match snapshot", () => {
+                const view = render(React.createElement(StatusLabel, { text: "End Aligned", alignment: "end" })).toJSON();
+                expect(view).toMatchSnapshot();
+            });
+        });
+    });
+    describe("status", () => {
+        describe('when status prop set to default ("success")', () => {
+            it("should match snapshot", () => {
+                const view = render(React.createElement(StatusLabel, { text: "Success" })).toJSON();
+                expect(view).toMatchSnapshot();
+            });
+        });
+        describe('when status prop set to "warning"', () => {
+            it("should match snapshot", () => {
+                const view = render(React.createElement(StatusLabel, { text: "Warning", status: "warning" })).toJSON();
+                expect(view).toMatchSnapshot();
+            });
+        });
+        describe('when status prop set to "critical"', () => {
+            it("should match snapshot", () => {
+                const view = render(React.createElement(StatusLabel, { text: "Critical", status: "critical" })).toJSON();
+                expect(view).toMatchSnapshot();
+            });
+        });
+        describe('when status prop set to "inactive"', () => {
+            it("should match snapshot", () => {
+                const view = render(React.createElement(StatusLabel, { text: "Inactive", status: "inactive" })).toJSON();
+                expect(view).toMatchSnapshot();
+            });
+        });
+        describe('when status prop set to "informative"', () => {
+            it("should match snapshot", () => {
+                const view = render(React.createElement(StatusLabel, { text: "Informative", status: "informative" })).toJSON();
+                expect(view).toMatchSnapshot();
+            });
+        });
+    });
+});

package/dist/src/Switch/Switch.test.js

@@ -0,0 +1,60 @@
+import React from "react";
+import { fireEvent, render } from "@testing-library/react-native";
+import { Switch } from "./Switch";
+it("renders a labeled Switch with value true", () => {
+    const { getByLabelText } = render(React.createElement(Switch, { value: true, label: "true switch" }));
+    const valueProp = getByLabelText("true switch").props.value;
+    expect(valueProp).toEqual(true);
+});
+it("renders a labeled Switch with value false", () => {
+    const { getByLabelText } = render(React.createElement(Switch, { value: false, label: "false switch" }));
+    const valueProp = getByLabelText("false switch").props.value;
+    expect(valueProp).toEqual(false);
+});
+it("renders an unlabeled Switch with value true", () => {
+    const { getByRole } = render(React.createElement(Switch, { value: true }));
+    const valueProp = getByRole("switch").props.value;
+    expect(valueProp).toEqual(true);
+});
+it("renders an unlabeled Switch with value false", () => {
+    const { getByRole } = render(React.createElement(Switch, { value: false }));
+    const valueProp = getByRole("switch").props.value;
+    expect(valueProp).toEqual(false);
+});
+describe("description", () => {
+    it("renders a Switch with label and description", () => {
+        const { getByText } = render(React.createElement(Switch, { label: "Label", description: "Description" }));
+        expect(getByText("Label")).toBeDefined();
+        expect(getByText("Description")).toBeDefined();
+    });
+    it("matches the width of the label and description", () => {
+        const { getByTestId } = render(React.createElement(Switch, { label: "Label", description: "Description" }));
+        const labelView = getByTestId("switch-label-view");
+        const descriptionView = getByTestId("switch-description-view");
+        fireEvent(labelView, "onLayout", {
+            nativeEvent: {
+                layout: {
+                    width: 123,
+                },
+            },
+        });
+        const flattenedStyle = descriptionView.props.style.reduce((style, additionalStyles) => (Object.assign(Object.assign({}, style), additionalStyles)), {});
+        expect(flattenedStyle).toEqual(expect.objectContaining({
+            maxWidth: 123,
+        }));
+    });
+});
+describe("accessibilityLabel", () => {
+    it("uses accessibilityLabel if specified", () => {
+        const { getByLabelText } = render(React.createElement(Switch, { value: true, label: "label", accessibilityLabel: "accessibilityLabel" }));
+        expect(getByLabelText("accessibilityLabel")).toBeTruthy();
+    });
+    it("uses placeholder if unspecified", () => {
+        const { getByLabelText } = render(React.createElement(Switch, { value: true, label: "label" }));
+        expect(getByLabelText("label")).toBeTruthy();
+    });
+    it("unavailable if unspecified", () => {
+        const { queryByLabelText } = render(React.createElement(Switch, { value: true }));
+        expect(queryByLabelText("label")).not.toBeTruthy();
+    });
+});

package/dist/src/Switch/components/BaseSwitch/BaseSwitch.test.js

@@ -0,0 +1,61 @@
+import React from "react";
+import { fireEvent, render } from "@testing-library/react-native";
+import { BaseSwitch } from "./BaseSwitch";
+describe("BaseSwitch", () => {
+    describe("rendering", () => {
+        it("renders with value true", () => {
+            const { getByRole } = render(React.createElement(BaseSwitch, { value: true }));
+            const switchElement = getByRole("switch");
+            expect(switchElement).toBeDefined();
+            expect(switchElement.props.accessibilityState.checked).toBe(true);
+        });
+        it("renders with defaultValue true", () => {
+            const { getByRole } = render(React.createElement(BaseSwitch, { defaultValue: true }));
+            const switchElement = getByRole("switch");
+            expect(switchElement).toBeDefined();
+            expect(switchElement.props.accessibilityState.checked).toBe(true);
+        });
+        it("renders with value false", () => {
+            const { getByRole } = render(React.createElement(BaseSwitch, { value: false }));
+            const switchElement = getByRole("switch");
+            expect(switchElement).toBeDefined();
+            expect(switchElement.props.accessibilityState.checked).toBe(false);
+        });
+        it("renders with defaultValue false", () => {
+            const { getByRole } = render(React.createElement(BaseSwitch, { defaultValue: false }));
+            const switchElement = getByRole("switch");
+            expect(switchElement).toBeDefined();
+            expect(switchElement.props.accessibilityState.checked).toBe(false);
+        });
+        it("renders correctly when disabled with value true", () => {
+            const { getByRole } = render(React.createElement(BaseSwitch, { value: true, disabled: true }));
+            const switchElement = getByRole("switch");
+            expect(switchElement).toBeDefined();
+            expect(switchElement.props.accessibilityState.checked).toBe(true);
+            expect(switchElement.props.accessibilityState.disabled).toBe(true);
+        });
+        it("renders correctly when disabled with value false", () => {
+            const { getByRole } = render(React.createElement(BaseSwitch, { value: false, disabled: true }));
+            const switchElement = getByRole("switch");
+            expect(switchElement).toBeDefined();
+            expect(switchElement.props.accessibilityState.checked).toBe(false);
+            expect(switchElement.props.accessibilityState.disabled).toBe(true);
+        });
+    });
+    describe("behavior", () => {
+        it("invokes the valueChange callback", () => {
+            const valueChangedCallback = jest.fn();
+            const { getByLabelText } = render(React.createElement(BaseSwitch, { value: false, onValueChange: valueChangedCallback, accessibilityLabel: "test switch" }));
+            fireEvent(getByLabelText("test switch"), "valueChange", true);
+            expect(valueChangedCallback).toHaveBeenCalledWith(true);
+            fireEvent(getByLabelText("test switch"), "valueChange", false);
+            expect(valueChangedCallback).toHaveBeenCalledWith(false);
+        });
+        it("doesn't invoke the valueChange callback if disabled", () => {
+            const valueChangedCallback = jest.fn();
+            const { getByLabelText } = render(React.createElement(BaseSwitch, { value: false, disabled: true, onValueChange: valueChangedCallback, accessibilityLabel: "test switch" }));
+            fireEvent(getByLabelText("test switch"), "valueChange", true);
+            expect(valueChangedCallback).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/src/Text/Text.test.js

@@ -0,0 +1,161 @@
+import React from "react";
+import { fireEvent, render, screen } from "@testing-library/react-native";
+import { Text } from ".";
+import { tokens } from "../utils/design";
+it("renders text with no additional props", () => {
+    const text = render(React.createElement(Text, null, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with base variation", () => {
+    const text = render(React.createElement(Text, { variation: "base" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with success variation", () => {
+    const text = render(React.createElement(Text, { variation: "success" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with error variation", () => {
+    const text = render(React.createElement(Text, { variation: "error" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with warn variation", () => {
+    const text = render(React.createElement(Text, { variation: "warn" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with info variation", () => {
+    const text = render(React.createElement(Text, { variation: "info" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with subdued variation", () => {
+    const text = render(React.createElement(Text, { variation: "subdued" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with success variation reverseTheme true", () => {
+    const text = render(React.createElement(Text, { variation: "success", reverseTheme: true }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with error variation reverseTheme true", () => {
+    const text = render(React.createElement(Text, { variation: "error", reverseTheme: true }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text supporting with no additional props", () => {
+    const text = render(React.createElement(Text, { level: "textSupporting" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text supporting with variation success", () => {
+    const text = render(React.createElement(Text, { level: "textSupporting", variation: "success" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text supporting with variation success reverseTheme true", () => {
+    const text = render(React.createElement(Text, { level: "textSupporting", variation: "success", reverseTheme: true }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with right alignment", () => {
+    const text = render(React.createElement(Text, { align: "end" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with center alignment", () => {
+    const text = render(React.createElement(Text, { align: "center" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with left alignment", () => {
+    const text = render(React.createElement(Text, { align: "start" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text that is scaled down with adjustsFontSize true", () => {
+    const text = render(React.createElement(Text, { maxLines: "base", adjustsFontSizeToFit: true }, "The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text that is not scaled down with adjustsFontSize false", () => {
+    const text = render(React.createElement(Text, { maxLines: "base", adjustsFontSizeToFit: false }, "The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog. The quick brown fox jumped over the lazy dog"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text with accessibilityRole set as text", () => {
+    const text = render(React.createElement(Text, null, "Test Text"));
+    expect(text.getByRole("text")).toBeDefined();
+});
+it("renders with strikethrough styling", () => {
+    const text = render(React.createElement(Text, { strikeThrough: true }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders with italic styling", () => {
+    const text = render(React.createElement(Text, { italic: true }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("renders text that is inaccessible", () => {
+    const text = render(React.createElement(Text, { hideFromScreenReader: true }, "Test Text"));
+    expect(text.root.props).toEqual(expect.objectContaining({
+        accessibilityRole: "none",
+        accessible: false,
+        importantForAccessibility: "no-hide-descendants",
+    }));
+});
+it("renders text with underline styling", () => {
+    const text = render(React.createElement(Text, { underline: "dotted" }, "Test Text"));
+    expect(text.toJSON()).toMatchSnapshot();
+});
+it("supports nested Text children with mixed styles", () => {
+    const { getByText, toJSON } = render(React.createElement(Text, null,
+        "Hello ",
+        React.createElement(Text, { emphasis: "strong" }, "World"),
+        "!"));
+    expect(getByText("World")).toBeDefined();
+    expect(toJSON()).toMatchSnapshot();
+});
+describe("UNSAFE_style", () => {
+    it("applies custom styles via UNSAFE_style prop", () => {
+        const customStyle = {
+            textStyle: {
+                fontSize: 20,
+                color: tokens["color-blue--dark"],
+            },
+        };
+        render(React.createElement(Text, { UNSAFE_style: customStyle }, "Test Text"));
+        const textElement = screen.getByRole("text");
+        expect(textElement.props.style).toContainEqual(expect.objectContaining(customStyle.textStyle));
+    });
+});
+describe("onTextLayout", () => {
+    it("calls onTextLayout callback when text layout event occurs", () => {
+        const onTextLayoutMock = jest.fn();
+        render(React.createElement(Text, { onTextLayout: onTextLayoutMock }, "Test Text"));
+        const textElement = screen.getByRole("text");
+        const mockEvent = {
+            nativeEvent: {
+                lines: [
+                    {
+                        text: "Test Text",
+                        x: 0,
+                        y: 0,
+                        width: 100,
+                        height: 20,
+                        ascender: 15,
+                        descender: -5,
+                        capHeight: 14,
+                        xHeight: 10,
+                    },
+                ],
+            },
+        };
+        fireEvent(textElement, "onTextLayout", mockEvent);
+        expect(onTextLayoutMock).toHaveBeenCalledTimes(1);
+        expect(onTextLayoutMock).toHaveBeenCalledWith(mockEvent);
+    });
+});
+describe("TypographyGestureDetector", () => {
+    it("wraps text with TypographyGestureDetector by default (collapsable=false)", () => {
+        const { getByRole } = render(React.createElement(Text, null, "Test Text"));
+        const textElement = getByRole("text");
+        expect(textElement.props.collapsable).toBe(false);
+    });
+    it("wraps text with TypographyGestureDetector (collapsable=false) when selectable=true", () => {
+        const { getByRole } = render(React.createElement(Text, { selectable: true }, "Test Text"));
+        const textElement = getByRole("text");
+        expect(textElement.props.collapsable).toBe(false);
+    });
+    it("does not wrap text with TypographyGestureDetector when selectable=false", () => {
+        const { getByRole } = render(React.createElement(Text, { selectable: false }, "Test Text"));
+        const textElement = getByRole("text");
+        expect(textElement.props.collapsable).toBeUndefined();
+    });
+});

package/dist/src/TextList/TextList.test.js

@@ -0,0 +1,16 @@
+import React from "react";
+import { render } from "@testing-library/react-native";
+import { TextList } from "./TextList";
+describe("TextList", () => {
+    describe("when the bulletItems is provided", () => {
+        it("displays the text list", () => {
+            const items = ["this is list item uno", "this is list item dos"];
+            const tree = render(React.createElement(TextList, { items: items }));
+            expect(tree.toJSON()).toMatchSnapshot();
+        });
+        it("displays will not display a bulleted list", () => {
+            const tree = render(React.createElement(TextList, null));
+            expect(tree.toJSON()).toMatchSnapshot();
+        });
+    });
+});

package/dist/src/ThumbnailList/ThumbnailList.test.js

@@ -0,0 +1,72 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React from "react";
+import { fireEvent, render, screen } from "@testing-library/react-native";
+import { ThumbnailList } from "./ThumbnailList";
+const snapshotFile = [
+    {
+        contentType: "image/jpeg",
+        fileName: "image.jpeg",
+        thumbnailUrl: "https://imageurl.com/ababathumb.jpg",
+        url: "https://imageurl.com/ababa1.jpg",
+        fileSize: 1024,
+    },
+];
+const files = [
+    {
+        contentType: "image/jpeg",
+        fileName: "image.jpeg",
+        thumbnailUrl: "https://imageurl.com/ababathumb.jpg",
+        url: "https://imageurl.com/ababa1.jpg",
+        fileSize: 1024,
+    },
+    {
+        contentType: "image/jpeg",
+        fileName: "image1.jpeg",
+        thumbnailUrl: "https://imageurl.com/ababathumb.jpg",
+        url: "https://imageurl.com/ababa2.jpg",
+        fileSize: 1024,
+    },
+    {
+        contentType: "pdf",
+        fileName: "image2.pdf",
+        thumbnailUrl: "https://imageurl.com/ababathumb.jpg",
+        url: undefined,
+        fileSize: 1024,
+    },
+];
+const onOpenFile = jest.fn();
+const mockCreateThumbnail = jest.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        thumbnail: "thumbnail",
+        error: false,
+    });
+}));
+function setup(snapshot) {
+    return render(React.createElement(ThumbnailList, { files: snapshot ? snapshotFile : files, handleOpenFile: onOpenFile, createThumbnail: mockCreateThumbnail }));
+}
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+it("renders a thumbnail component with attachments", () => {
+    setup(true);
+    expect(screen.toJSON()).toMatchSnapshot();
+});
+describe("when a an array of files is provided", () => {
+    it("calls the previewImages util on pressing a valid file", () => {
+        setup();
+        fireEvent.press(screen.getByLabelText(files[0].fileName ? files[0].fileName : "file"));
+        expect(onOpenFile).toHaveBeenCalledTimes(1);
+    });
+    it("calls createThumbnail", () => {
+        setup();
+        expect(mockCreateThumbnail).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/src/Toast/Toast.test.js

@@ -0,0 +1,51 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React from "react";
+import { fireEvent, render, screen, waitFor, } from "@testing-library/react-native";
+import { AccessibilityInfo } from "react-native";
+import { Toast, showToast } from ".";
+import { Button } from "../Button";
+import { MockSafeAreaProvider } from "../utils/test";
+function expectToastWithMessage(message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        expect(yield screen.findByText(message)).toBeDefined();
+        yield waitFor(() => {
+            // We also need to assert the accessibility info because otherwise
+            // the test will 'overflow' and cause other tests to fail.
+            expect(AccessibilityInfo.announceForAccessibility).toHaveBeenCalledWith(message);
+            jest.mocked(AccessibilityInfo.announceForAccessibility).mockClear();
+        });
+    });
+}
+function setup({ bottomOffset, message = "Notify message" }) {
+    return render(React.createElement(MockSafeAreaProvider, null,
+        React.createElement(Button, { label: "Press me", accessibilityLabel: "Button label", onPress: () => showToast({ message, bottomTabsVisible: false }) }),
+        React.createElement(Toast, { bottomOffset: bottomOffset })));
+}
+describe("Toast", () => {
+    it("shows the toast on trigger", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { getByLabelText } = setup({ bottomOffset: 20 });
+        const toastTriggerButton = getByLabelText("Button label");
+        fireEvent.press(toastTriggerButton);
+        yield expectToastWithMessage("Notify message");
+    }));
+    describe("When the message length exceed the defined maximum", () => {
+        const over60CharactersMsg = "really really really really really really really really really really really really really really really really really really really long message";
+        it("should log a warning that the message length is too long", () => __awaiter(void 0, void 0, void 0, function* () {
+            const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+            const { getByLabelText } = setup({ message: over60CharactersMsg });
+            const toastTriggerButton = getByLabelText("Button label");
+            fireEvent.press(toastTriggerButton);
+            yield expectToastWithMessage(over60CharactersMsg);
+            expect(consoleSpy).toHaveBeenCalledWith("Jobber Design Warning: Message length limit exceeded, your current length is 145, the maximum allowed is 60. please talk with your designer");
+            consoleSpy.mockRestore();
+        }));
+    });
+});