@jobber/components-native 0.101.3 → 0.101.4

package/dist/src/Form/components/FormSaveButton/FormSaveButton.test.js

@@ -0,0 +1,82 @@
+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, waitFor } from "@testing-library/react-native";
+import { FormSaveButton } from "./FormSaveButton";
+jest.mock("react-hook-form", () => (Object.assign(Object.assign({}, jest.requireActual("react-hook-form")), { useFormContext: () => ({
+        reset: () => jest.fn(),
+    }) })));
+function ButtonGroupForTest(props) {
+    return (React.createElement(FormSaveButton, { primaryAction: props.primaryAction, loading: props.loading, label: props.label, setSecondaryActionLoading: props.setSecondaryActionLoading, secondaryActions: props.secondaryAction }));
+}
+describe("the form save button is enabled", () => {
+    const loading = false;
+    it("renders the form save button with default label", () => {
+        const pressHandler = jest.fn();
+        const { getByLabelText } = render(React.createElement(ButtonGroupForTest, { primaryAction: pressHandler, loading: loading, setSecondaryActionLoading: jest.fn() }));
+        const saveButton = getByLabelText("Save");
+        expect(saveButton).toBeTruthy();
+    });
+    it("renders a save button and calls the onPress handler when pressed", () => {
+        const pressHandler = jest.fn();
+        const saveButtonText = "Save";
+        const { getByLabelText } = render(React.createElement(ButtonGroupForTest, { primaryAction: pressHandler, loading: loading, setSecondaryActionLoading: jest.fn() }));
+        fireEvent.press(getByLabelText(saveButtonText));
+        expect(pressHandler).toHaveBeenCalled();
+    });
+    it("renders a save button with a custom label if provided", () => {
+        const pressHandler = jest.fn();
+        const saveButtonText = "MySave";
+        const { getByLabelText } = render(React.createElement(ButtonGroupForTest, { primaryAction: pressHandler, loading: loading, setSecondaryActionLoading: jest.fn(), label: saveButtonText }));
+        const saveButton = getByLabelText(saveButtonText);
+        expect(saveButton).toBeTruthy();
+    });
+});
+describe("the form save button is loading", () => {
+    const loading = true;
+    it("renders the form save button as loading", () => {
+        const pressHandler = jest.fn();
+        const { getByTestId, getByRole } = render(React.createElement(ButtonGroupForTest, { primaryAction: pressHandler, loading: loading, setSecondaryActionLoading: jest.fn() }));
+        expect(getByTestId("loadingImage")).toBeDefined();
+        expect(getByRole("button", { busy: true })).toBeDefined();
+    });
+});
+describe("when a secondaryActions is passed in", () => {
+    it("renders a secondaryAction element", () => {
+        const pressHandler = jest.fn();
+        const { getByLabelText } = render(React.createElement(ButtonGroupForTest, { primaryAction: pressHandler, loading: false, setSecondaryActionLoading: jest.fn(), secondaryAction: [
+                { label: "hi", handleAction: { onSubmit: jest.fn() } },
+            ] }));
+        expect(getByLabelText("More")).toBeDefined();
+    });
+    it("renders a secondaryAction element with and fires the onSubmit and beforeSubmit if available", () => __awaiter(void 0, void 0, void 0, function* () {
+        const pressHandler = jest.fn(() => Promise.resolve());
+        const beforeSubmitMock = jest.fn().mockImplementation(() => {
+            return Promise.resolve(true);
+        });
+        const { findByLabelText, getByLabelText } = render(React.createElement(ButtonGroupForTest, { primaryAction: pressHandler, loading: false, setSecondaryActionLoading: jest.fn(), secondaryAction: [
+                {
+                    icon: "trash",
+                    label: "hi",
+                    handleAction: {
+                        onSubmit: pressHandler,
+                        onBeforeSubmit: beforeSubmitMock,
+                    },
+                },
+            ] }));
+        fireEvent.press(getByLabelText("More"));
+        expect(yield findByLabelText("hi")).toBeDefined();
+        fireEvent.press(getByLabelText("hi"));
+        expect(beforeSubmitMock).toHaveBeenCalled();
+        yield waitFor(() => {
+            expect(pressHandler).toHaveBeenCalled();
+        });
+    }));
+});

package/dist/src/Form/context/AtlantisFormContext.test.js

@@ -0,0 +1,28 @@
+import React from "react";
+import { renderHook } from "@testing-library/react-native";
+import { AtlantisFormContext, atlantisFormContextDefaultValues, useAtlantisFormContext, } from "./AtlantisFormContext";
+const useConfirmBeforeBackMock = jest.fn();
+const useInternalFormLocalCacheMock = jest.fn();
+const providerValues = {
+    useConfirmBeforeBack: useConfirmBeforeBackMock,
+    useInternalFormLocalCache: useInternalFormLocalCacheMock,
+};
+describe("AtlantisFormContext", () => {
+    beforeEach(() => {
+        jest.resetModules();
+    });
+    describe("No Provider", () => {
+        it("should get the default values", () => {
+            const { result } = renderHook(() => useAtlantisFormContext());
+            expect(result.current).toMatchObject(atlantisFormContextDefaultValues);
+        });
+    });
+    describe("With Provider", () => {
+        it("should get the provider values", () => {
+            const { result } = renderHook(() => useAtlantisFormContext(), {
+                wrapper: ({ children }) => (React.createElement(AtlantisFormContext.Provider, { value: providerValues }, children)),
+            });
+            expect(result.current).toMatchObject(providerValues);
+        });
+    });
+});

package/dist/src/Form/hooks/useScrollToError/useScrollToError.test.js

@@ -0,0 +1,89 @@
+import { renderHook } from "@testing-library/react-native";
+import { useScrollToError } from "./useScrollToError";
+const mockFormState = {
+    isDirty: true,
+    isLoading: false,
+    isReady: true,
+    disabled: false,
+    validatingFields: {},
+    dirtyFields: {},
+    isSubmitted: false,
+    isSubmitSuccessful: false,
+    submitCount: 0,
+    touchedFields: {},
+    isSubmitting: false,
+    isValidating: false,
+    isValid: true,
+    errors: {},
+};
+const mockScreenReaderEnabled = jest.fn().mockReturnValue(false);
+jest.mock("../../../hooks/useIsScreenReaderEnabled", () => ({
+    useIsScreenReaderEnabled: () => mockScreenReaderEnabled(),
+}));
+jest.mock("../../../ErrorMessageWrapper", () => ({
+    useErrorMessageContext: () => ({
+        elements: {
+            el: {
+                measure: jest.fn((_, callback) => callback()),
+                hasErrorMessage: true,
+                accessibilityFocus: jest.fn(),
+            },
+        },
+        register: jest.fn(),
+        unregister: jest.fn(),
+    }),
+}));
+const handleScrollTo = jest.fn();
+const handleSetFocus = jest.fn();
+const initialProps = {
+    formState: mockFormState,
+    refNode: 1,
+    scrollTo: handleScrollTo,
+    setFocus: handleSetFocus,
+};
+afterEach(() => {
+    handleScrollTo.mockClear();
+    handleSetFocus.mockClear();
+});
+describe("useScrollToError", () => {
+    it("should do nothing if everything is valid", () => {
+        renderHook((props) => useScrollToError(props), {
+            initialProps,
+        });
+        expect(handleSetFocus).not.toHaveBeenCalled();
+        expect(handleScrollTo).not.toHaveBeenCalled();
+    });
+    it("should focus with RHF if it can", () => {
+        const { rerender } = renderHook((props) => useScrollToError(props), {
+            initialProps,
+        });
+        rerender(Object.assign(Object.assign({}, initialProps), { formState: Object.assign(Object.assign({}, mockFormState), { isValid: false, submitCount: 1 }) }));
+        expect(handleSetFocus).toHaveBeenCalled();
+        expect(handleScrollTo).not.toHaveBeenCalled();
+    });
+    it("should manually scroll", () => {
+        // @ts-expect-error - making this fail when it gets called since you can't
+        // call undefined as a function. This mimic's RHF not being able to focus on
+        // non-input fields
+        const failedSetFocus = jest.fn(() => failingFn());
+        const manualScrollProps = Object.assign(Object.assign({}, initialProps), { setFocus: failedSetFocus });
+        const { rerender } = renderHook((props) => useScrollToError(props), {
+            initialProps: manualScrollProps,
+        });
+        rerender(Object.assign(Object.assign({}, manualScrollProps), { formState: Object.assign(Object.assign({}, mockFormState), { isValid: false, submitCount: 1 }) }));
+        expect(failedSetFocus).toHaveBeenCalled();
+        expect(failedSetFocus).toThrow();
+        expect(handleScrollTo).toHaveBeenCalled();
+    });
+    describe("With screen readers", () => {
+        it("should not fire the setFocus", () => {
+            mockScreenReaderEnabled.mockReturnValue(true);
+            const { rerender } = renderHook((props) => useScrollToError(props), {
+                initialProps,
+            });
+            rerender(Object.assign(Object.assign({}, initialProps), { formState: Object.assign(Object.assign({}, mockFormState), { isValid: false, submitCount: 1 }) }));
+            expect(handleSetFocus).not.toHaveBeenCalled();
+            expect(handleScrollTo).toHaveBeenCalled();
+        });
+    });
+});

package/dist/src/FormField/FormField.test.js

@@ -0,0 +1,81 @@
+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, waitFor } from "@testing-library/react-native";
+import { FormProvider, useForm } from "react-hook-form";
+import { Button } from "react-native";
+import { FormField } from ".";
+import { InputText } from "../InputText";
+const mockOnSubmit = jest.fn();
+const inputAccessibilityLabel = "textInput";
+const saveButtonText = "Save Me";
+describe("when a component is wrapped in a FormField within a Form", () => {
+    function SimpleFormWithProvider({ children, }) {
+        const formMethods = useForm();
+        return (React.createElement(FormProvider, Object.assign({}, formMethods),
+            children,
+            React.createElement(Button, { onPress: formMethods.handleSubmit(values => mockOnSubmit(values)), title: saveButtonText, accessibilityLabel: saveButtonText })));
+    }
+    describe("when the component's value is changed", () => {
+        it("updates the form value for that component", () => __awaiter(void 0, void 0, void 0, function* () {
+            const defaultInputValue = "Sonkey";
+            const newInputValue = "Donic";
+            const { getByLabelText } = render(React.createElement(SimpleFormWithProvider, null,
+                React.createElement(FormField, { name: "formTextInput", defaultValue: defaultInputValue }, field => {
+                    return (React.createElement(InputText, { name: field.name, accessibilityLabel: inputAccessibilityLabel, value: field.value, onChangeText: field.onChange }));
+                })));
+            const textInput = getByLabelText(inputAccessibilityLabel);
+            fireEvent.changeText(textInput, newInputValue);
+            const saveButton = getByLabelText(saveButtonText);
+            yield waitFor(() => {
+                fireEvent.press(saveButton);
+            });
+            expect(mockOnSubmit).toHaveBeenCalledWith({
+                formTextInput: newInputValue,
+            });
+        }));
+    });
+    describe("when the validations of the component are violated", () => {
+        it("returns an error from the FormField wrapper", () => __awaiter(void 0, void 0, void 0, function* () {
+            const newInputValue = "Exceeding 5 characters";
+            const maxLengthErrorMessage = "error: max length exceeded";
+            const { getByLabelText, getAllByText } = render(React.createElement(SimpleFormWithProvider, null,
+                React.createElement(FormField, { name: "formTextInput", validations: {
+                        maxLength: {
+                            value: 5,
+                            message: maxLengthErrorMessage,
+                        },
+                    } }, field => {
+                    return (React.createElement(InputText, { name: field.name, accessibilityLabel: inputAccessibilityLabel, value: field.value, onChangeText: field.onChange }));
+                })));
+            const textInput = getByLabelText(inputAccessibilityLabel);
+            fireEvent.changeText(textInput, newInputValue);
+            const saveButton = getByLabelText(saveButtonText);
+            yield waitFor(() => {
+                fireEvent.press(saveButton);
+            });
+            expect(getAllByText(maxLengthErrorMessage, { includeHiddenElements: true })).toHaveLength(1);
+        }));
+    });
+});
+describe("when a component is not in a Form with a Form ProviderField within a Form", () => {
+    describe("when the component's value is changed", () => {
+        it("updates the form value for that component", () => __awaiter(void 0, void 0, void 0, function* () {
+            const defaultInputValue = "Sonkey";
+            const newInputValue = "Donic";
+            const { getByDisplayValue, getByLabelText } = render(React.createElement(FormField, { name: "formTextInput", defaultValue: defaultInputValue }, field => {
+                return (React.createElement(InputText, { name: field.name, accessibilityLabel: inputAccessibilityLabel, value: field.value, onChangeText: field.onChange }));
+            }));
+            const textInput = getByLabelText(inputAccessibilityLabel);
+            fireEvent.changeText(textInput, newInputValue);
+            expect(getByDisplayValue(newInputValue)).toBeDefined();
+        }));
+    });
+});

package/dist/src/FormatFile/FormatFile.test.js

@@ -0,0 +1,212 @@
+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, waitFor } from "@testing-library/react-native";
+import { Alert } from "react-native";
+import { FormatFile } from ".";
+import { FILE_MOCK_FILE, FILE_MOCK_IMAGE, FILE_MOCK_PDF, FILE_MOCK_VIDEO, FILE_UPLOAD_MOCK_FILE, FILE_UPLOAD_MOCK_IMAGE, FILE_UPLOAD_MOCK_PDF, } from "./components/_mocks/mockFiles";
+import { StatusCode } from "./types";
+import { tokens } from "../utils/design";
+let Platform;
+const onRemove = jest.fn();
+const mockOnPreview = jest.fn();
+const mockCreateThumbnail = jest.fn(() => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        thumbnail: "thumbnail",
+        error: false,
+    });
+}));
+beforeEach(() => {
+    Platform = require("react-native").Platform;
+});
+afterEach(() => {
+    jest.clearAllMocks();
+});
+const renderFormatFile = (file, bottomSheetOptionsSuffix, showFileTypeIndicator) => {
+    return render(React.createElement(FormatFile, { file: file, accessibilityLabel: "Custom Label", accessibilityHint: "Custom Hint Text", onTap: () => Alert.alert("alert"), onRemove: onRemove, bottomSheetOptionsSuffix: bottomSheetOptionsSuffix, showFileTypeIndicator: showFileTypeIndicator, onPreviewPress: mockOnPreview, createThumbnail: mockCreateThumbnail }));
+};
+function basicRenderTestWithValue() {
+    const progressBarAnimationTime = 500;
+    it.each([
+        [
+            "file",
+            FILE_UPLOAD_MOCK_FILE({ progress: 1, status: StatusCode.Completed }),
+        ],
+        [
+            "image",
+            FILE_UPLOAD_MOCK_IMAGE({ progress: 1, status: StatusCode.Completed }),
+        ],
+    ])("renders a %s with custom label and hint", (bottomSheetOptionsSuffix, file) => {
+        const { getByLabelText, getByHintText } = renderFormatFile(file, bottomSheetOptionsSuffix);
+        expect(getByLabelText("Custom Label")).toBeDefined();
+        expect(getByHintText("Custom Hint Text")).toBeDefined();
+    });
+    describe.each([
+        ["file", FILE_UPLOAD_MOCK_FILE({ progress: 0.9 })],
+        ["image", FILE_UPLOAD_MOCK_IMAGE({ progress: 0.9 })],
+    ])("when a local %s is being uploaded", (testIdType, file) => {
+        const testId = `test-${testIdType}`;
+        it("renders ProgressBar state when upload status is not completed", () => {
+            const { getByTestId } = renderFormatFile(file);
+            expect(getByTestId("format-file-progress-bar")).toBeDefined();
+        });
+        it("renders a helpful accessibility label", () => {
+            const tree = renderFormatFile(file);
+            expect(tree.getByLabelText("Upload in progress.")).toBeDefined();
+        });
+        it("renders an overlay on the image when upload status is not completed", () => {
+            const { getByTestId } = renderFormatFile(file);
+            const progressBarContainer = getByTestId("format-file-progress-bar-container");
+            const overlayStyles = progressBarContainer.props.style;
+            // The container needs to have a height and color in order to show the overlay
+            expect(overlayStyles).toEqual(expect.arrayContaining([expect.objectContaining({ height: "100%" })]));
+            expect(overlayStyles).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    backgroundColor: tokens["color-overlay--dimmed"],
+                }),
+            ]));
+        });
+        it("renders ProgressBar state advancing with the upload percentage", () => __awaiter(this, void 0, void 0, function* () {
+            jest.useFakeTimers();
+            const { getByTestId } = renderFormatFile(file);
+            jest.advanceTimersByTime(progressBarAnimationTime);
+            const formatFileInnerProgressBar = yield waitFor(() => getByTestId("format-file-inner-progress-bar"));
+            const innerProgressBarWidth = parseInt(formatFileInnerProgressBar.props.style.width, 10);
+            expect(innerProgressBarWidth).toBeGreaterThan(20);
+        }));
+        it("shows an alert for on tap", () => {
+            const { getByTestId } = renderFormatFile(file);
+            const spy = jest.spyOn(Alert, "alert");
+            fireEvent.press(getByTestId(testId));
+            expect(spy).toHaveBeenCalled();
+        });
+    });
+    describe.each([
+        [
+            "file",
+            Object.assign(Object.assign({}, FILE_UPLOAD_MOCK_FILE({ progress: 0.9, status: StatusCode.Failed })), { status: StatusCode.Failed }),
+        ],
+        [
+            "image",
+            Object.assign(Object.assign({}, FILE_UPLOAD_MOCK_IMAGE({ progress: 0.9, status: StatusCode.Failed })), { status: StatusCode.Failed }),
+        ],
+    ])("when a local %s upload has failed", (testIdType, file) => {
+        it("renders an error icon", () => {
+            const tree = renderFormatFile(file);
+            expect(tree.getByTestId("format-file-error-icon")).toBeDefined();
+        });
+        it("renders a helpful accessibility label", () => {
+            const tree = renderFormatFile(file);
+            expect(tree.getByLabelText("Failed to upload.")).toBeDefined();
+        });
+        it("does not render an overlay", () => {
+            const tree = renderFormatFile(file);
+            expect(tree.queryByTestId("format-file-progress-bar-container")).toBeNull();
+        });
+        it("shows an alert for on tap", () => {
+            const testId = `test-${testIdType}`;
+            const tree = renderFormatFile(file);
+            const spy = jest.spyOn(Alert, "alert");
+            fireEvent.press(tree.getByTestId(testId));
+            expect(spy).toHaveBeenCalled();
+        });
+    });
+    describe.each([
+        [
+            "local file",
+            "test-file",
+            FILE_UPLOAD_MOCK_FILE({ progress: 1, status: StatusCode.Completed }),
+        ],
+        [
+            "local image",
+            "test-image",
+            FILE_UPLOAD_MOCK_IMAGE({ progress: 1, status: StatusCode.Completed }),
+        ],
+        ["external file", "test-file", FILE_MOCK_FILE],
+        ["external image", "test-image", FILE_MOCK_IMAGE],
+    ])("when a uploaded %s is being used", (bottomSheetOptionsSuffix, testId, file) => {
+        let tree;
+        const removeLabel = `Remove ${bottomSheetOptionsSuffix}`;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.useFakeTimers();
+            tree = renderFormatFile(file, bottomSheetOptionsSuffix);
+            jest.advanceTimersByTime(progressBarAnimationTime);
+        });
+        it("shows a BottomSheet with a remove option when tapped", () => __awaiter(this, void 0, void 0, function* () {
+            const { getByTestId, findByLabelText } = tree;
+            fireEvent.press(getByTestId(testId));
+            expect(yield findByLabelText(removeLabel)).toBeDefined();
+        }));
+        describe("when the BottomSheet remove option is tapped", () => {
+            it("calls the onRemove action", () => __awaiter(this, void 0, void 0, function* () {
+                const { getByTestId, findByLabelText } = tree;
+                fireEvent.press(getByTestId(testId));
+                fireEvent.press(yield findByLabelText(removeLabel));
+                expect(onRemove).toHaveBeenCalledTimes(1);
+            }));
+        });
+        it("creates a thumbnail when a media file is used", () => {
+            const expectedCalls = testId.includes("image") ? 1 : 0;
+            expect(mockCreateThumbnail).toHaveBeenCalledTimes(expectedCalls);
+        });
+    });
+    describe("when the preview option is tapped", () => {
+        it("calls onPreview with a valid image", () => __awaiter(this, void 0, void 0, function* () {
+            const previewLabel = "Preview image";
+            const { getByTestId, findByLabelText } = renderFormatFile(FILE_UPLOAD_MOCK_IMAGE({ progress: 1, status: StatusCode.Completed }), "image");
+            fireEvent.press(getByTestId("test-image"));
+            fireEvent.press(yield findByLabelText(previewLabel));
+            expect(mockOnPreview).toHaveBeenCalledTimes(1);
+        }));
+        it("calls onPreview with a valid pdf file", () => __awaiter(this, void 0, void 0, function* () {
+            const previewLabel = "Preview file";
+            const { getByTestId, findByLabelText } = renderFormatFile(FILE_UPLOAD_MOCK_PDF({ progress: 1, status: StatusCode.Completed }), "file");
+            fireEvent.press(getByTestId("test-file"));
+            fireEvent.press(yield findByLabelText(previewLabel));
+            expect(mockOnPreview).toHaveBeenCalledTimes(1);
+        }));
+        it("calls onPreview with a valid external PDF file", () => __awaiter(this, void 0, void 0, function* () {
+            const previewLabel = "Preview file";
+            const { getByTestId, findByLabelText } = renderFormatFile(FILE_MOCK_PDF, "file");
+            fireEvent.press(getByTestId("test-file"));
+            fireEvent.press(yield findByLabelText(previewLabel));
+            expect(mockOnPreview).toHaveBeenCalledTimes(1);
+        }));
+        it("does not show the preview option with an unaccepted file", () => {
+            const previewLabel = "Preview file";
+            const { getByTestId, queryByLabelText } = renderFormatFile(FILE_UPLOAD_MOCK_FILE({ progress: 1, status: StatusCode.Completed }), "file");
+            fireEvent.press(getByTestId("test-file"));
+            expect(queryByLabelText(previewLabel)).toBeNull();
+        });
+    });
+    describe("when an uploaded video is being viewed", () => {
+        it("shows the play icon if the file type indicator is not specified", () => {
+            const { getByTestId } = renderFormatFile(FILE_MOCK_VIDEO, "video");
+            expect(getByTestId("video")).toBeDefined();
+        });
+        it("does not show the play icon if the file type indicator is set to false", () => {
+            const { queryByTestId } = renderFormatFile(FILE_MOCK_VIDEO, "video", false);
+            expect(queryByTestId("video")).toBeNull();
+        });
+    });
+}
+describe("ios", () => {
+    beforeEach(() => {
+        Platform.OS = "ios";
+    });
+    basicRenderTestWithValue();
+});
+describe("android", () => {
+    beforeEach(() => {
+        Platform.OS = "android";
+    });
+    basicRenderTestWithValue();
+});