@jobber/components-native 0.101.3 → 0.101.4

package/dist/src/InputNumber/InputNumber.test.js

@@ -0,0 +1,220 @@
+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 { InputNumber } from ".";
+let Platform;
+beforeEach(() => {
+    Platform = require("react-native").Platform;
+});
+const platforms = ["ios", "android"];
+it.each(platforms)("renders an InputNumber on %s", platform => {
+    Platform.OS = platform;
+    const label = "My Accessible label";
+    const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: label }));
+    expect(getByLabelText(label)).toBeTruthy();
+});
+it.each(platforms)("renders an InputNumber with defaultValue on %s", platform => {
+    Platform.OS = platform;
+    const value = 200;
+    const { getByDisplayValue } = render(React.createElement(InputNumber, { value: value }));
+    expect(getByDisplayValue(value.toString())).toBeTruthy();
+});
+const notANumberErrorMessage = "Enter a number";
+it("Displays a validation message when the value is not a number", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { getByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const inputValue = "this";
+    fireEvent.changeText(getByLabelText(a11yLabel), inputValue);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(getByText(notANumberErrorMessage, {
+        includeHiddenElements: true,
+    })).toBeDefined();
+    expect(onChange).toHaveBeenCalledWith(inputValue);
+}));
+it("When onChange is called it returns a number", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    fireEvent.changeText(getByLabelText(a11yLabel), "100");
+    expect(onChange).toHaveBeenCalledWith(100);
+}));
+it("doesn't change the value when the input is controlled without an onChange", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const initialValue = 12;
+    const changeValue = 100;
+    const { queryByText, getByLabelText, getByDisplayValue } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, value: initialValue }));
+    fireEvent.changeText(getByLabelText(a11yLabel), changeValue.toString());
+    expect(queryByText(changeValue.toString())).toBeNull();
+    expect(getByDisplayValue(initialValue.toString())).toBeDefined();
+}));
+it("passes validation when decimal value is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { queryByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const numInput = "13.5";
+    fireEvent.changeText(getByLabelText(a11yLabel), numInput);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(queryByText(notANumberErrorMessage)).toBeNull();
+    expect(onChange).toHaveBeenCalledWith(parseFloat(numInput));
+}));
+it("passes validation when negative value is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { queryByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const numInput = "-15";
+    fireEvent.changeText(getByLabelText(a11yLabel), numInput);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(queryByText(notANumberErrorMessage)).toBeNull();
+    expect(onChange).toHaveBeenCalledWith(parseInt(numInput, 10));
+}));
+it("passes validation when negative decimal value is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { queryByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const numInput = "-15.123";
+    fireEvent.changeText(getByLabelText(a11yLabel), numInput);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(queryByText(notANumberErrorMessage)).toBeNull();
+    expect(onChange).toHaveBeenCalledWith(parseFloat(numInput));
+}));
+it("passes validation when explicit positive value is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { queryByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const numInput = "+15";
+    fireEvent.changeText(getByLabelText(a11yLabel), numInput);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(queryByText(notANumberErrorMessage)).toBeNull();
+    expect(onChange).toHaveBeenCalledWith(parseInt(numInput, 10));
+}));
+it("passes validation when e notation value is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { queryByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const numInput = "6e10";
+    fireEvent.changeText(getByLabelText(a11yLabel), numInput);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(queryByText(notANumberErrorMessage)).toBeNull();
+    expect(onChange).toHaveBeenCalledWith(parseFloat(numInput));
+}));
+it("passes validation when e notation decimal value is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { queryByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const numInput = "6.456e10";
+    fireEvent.changeText(getByLabelText(a11yLabel), numInput);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(queryByText(notANumberErrorMessage)).toBeNull();
+    expect(onChange).toHaveBeenCalledWith(parseFloat(numInput));
+}));
+it("passes validation when e notation for representing decimal value is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+    const a11yLabel = "InputNumberTest";
+    const onChange = jest.fn();
+    const { queryByText, getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+    const numInput = "6e-10";
+    fireEvent.changeText(getByLabelText(a11yLabel), numInput);
+    yield waitFor(() => {
+        fireEvent(getByLabelText(a11yLabel), "blur");
+    });
+    expect(queryByText(notANumberErrorMessage)).toBeNull();
+    expect(onChange).toHaveBeenCalledWith(parseFloat(numInput));
+}));
+describe("when the value ends with period", () => {
+    const values = [".", "0.", "12.", "+1.", "-0."];
+    it.each(values)("doesn't convert the value %s", value => {
+        const a11yLabel = "InputNumberTest";
+        const onChange = jest.fn();
+        const { getByLabelText, getByDisplayValue } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+        fireEvent.changeText(getByLabelText(a11yLabel), value);
+        expect(getByDisplayValue(value)).toBeDefined();
+    });
+});
+describe("when the value ends with scientific notation", () => {
+    const values = ["1e", "+2e", "1.2e", "-3e"];
+    it.each(values)("doesn't convert the value %s", value => {
+        const a11yLabel = "InputNumberTest";
+        const onChange = jest.fn();
+        const { getByLabelText, getByDisplayValue } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+        fireEvent.changeText(getByLabelText(a11yLabel), value);
+        expect(getByDisplayValue(value)).toBeDefined();
+    });
+});
+describe("when the value ends with + or -", () => {
+    const values = ["+", "-"];
+    it.each(values)("doesn't convert the value %s", value => {
+        const a11yLabel = "InputNumberTest";
+        const onChange = jest.fn();
+        const { getByLabelText, getByDisplayValue } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+        fireEvent.changeText(getByLabelText(a11yLabel), value);
+        expect(getByDisplayValue(value)).toBeDefined();
+    });
+});
+describe("when the value ends with zero decimal", () => {
+    const values = ["0.0", "+0.00000", "-3.00000", "2.100", ".0", ".00000"];
+    it.each(values)("doesn't convert the value %s", value => {
+        const a11yLabel = "InputNumberTest";
+        const onChange = jest.fn();
+        const { getByLabelText, getByDisplayValue } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, onChange: onChange }));
+        fireEvent.changeText(getByLabelText(a11yLabel), value);
+        expect(getByDisplayValue(value)).toBeDefined();
+    });
+});
+describe("when the OS is iOS", () => {
+    const a11yLabel = "InputNumberTest";
+    beforeEach(() => {
+        Platform.OS = "ios";
+    });
+    it("uses the decimal-pad keyboard when keyboard is 'decimal-pad'", () => {
+        const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, keyboard: "decimal-pad" }));
+        expect(getByLabelText(a11yLabel).props.keyboardType).toEqual("decimal-pad");
+    });
+    it("uses the default numbers-and-punctuation keyboard when missing keyboard prop", () => {
+        const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel }));
+        expect(getByLabelText(a11yLabel).props.keyboardType).toEqual("numbers-and-punctuation");
+    });
+    it("uses the numbers-and-punctuation keyboard when keyboard is 'numbers-and-punctuation'", () => {
+        const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, keyboard: "numbers-and-punctuation" }));
+        expect(getByLabelText(a11yLabel).props.keyboardType).toEqual("numbers-and-punctuation");
+    });
+});
+describe("when the OS is android", () => {
+    const a11yLabel = "InputNumberTest";
+    beforeEach(() => {
+        Platform.OS = "android";
+    });
+    it("uses the numeric keyboard when missing keyboard prop", () => {
+        const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel }));
+        expect(getByLabelText(a11yLabel).props.keyboardType).toEqual("numeric");
+    });
+    it("uses the numeric keyboard when keyboard is 'decimal-pad'", () => {
+        const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, keyboard: "decimal-pad" }));
+        expect(getByLabelText(a11yLabel).props.keyboardType).toEqual("numeric");
+    });
+    it("uses the numeric keyboard when keyboard is 'numbers-and-punctuation'", () => {
+        const { getByLabelText } = render(React.createElement(InputNumber, { accessibilityLabel: a11yLabel, keyboard: "numbers-and-punctuation" }));
+        expect(getByLabelText(a11yLabel).props.keyboardType).toEqual("numeric");
+    });
+});

package/dist/src/InputPassword/InputPassword.test.js

@@ -0,0 +1,63 @@
+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 { InputPassword } from "./InputPassword";
+const MockInputFieldWrapper = jest.fn();
+jest.mock("../InputFieldWrapper", () => (Object.assign(Object.assign({}, jest.requireActual("../InputFieldWrapper")), { InputFieldWrapper: function Mock(props) {
+        MockInputFieldWrapper(props);
+        return jest.requireActual("../InputFieldWrapper").InputFieldWrapper(props);
+    } })));
+describe("InputPassword", () => {
+    it("renders an InputPassword", () => {
+        const value = "password";
+        const { getByDisplayValue } = render(React.createElement(InputPassword, { value: value }));
+        expect(getByDisplayValue(value)).toBeTruthy();
+    });
+    it("displays the validation message when an invalid password is entered", () => __awaiter(void 0, void 0, void 0, function* () {
+        const a11yLabel = "InputPasswordTest";
+        const { getByText, getByLabelText } = render(React.createElement(InputPassword, { value: "", accessibilityLabel: a11yLabel }));
+        yield waitFor(() => {
+            fireEvent(getByLabelText(a11yLabel), "blur");
+        });
+        expect(getByText("Enter a password", {
+            includeHiddenElements: true,
+        })).toBeDefined();
+    }));
+    describe("InputPassword gets the expected props", () => {
+        it("renders an invalid InputPassword", () => {
+            const props = { invalid: true };
+            render(React.createElement(InputPassword, Object.assign({}, props)));
+            expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining(props));
+        });
+    });
+    describe("Privacy eye", () => {
+        it("renders when usePrivaryEye is true", () => {
+            const testId = "eye";
+            const { getByTestId } = render(React.createElement(InputPassword, { value: "password", suffix: {
+                    icon: testId,
+                } }));
+            expect(getByTestId("eye")).toBeDefined();
+        });
+        it("does not render when usePrivaryEye is false", () => {
+            const testId = "eye";
+            const { queryByTestId } = render(React.createElement(InputPassword, { value: "password", usePrivacyEye: false, suffix: {
+                    icon: testId,
+                } }));
+            expect(queryByTestId("eye")).toBeNull();
+        });
+        it("obscures the password by default", () => {
+            const { getByDisplayValue } = render(React.createElement(InputPassword, { value: "password", suffix: {
+                    icon: "eye",
+                } }));
+            expect(getByDisplayValue("password").props.secureTextEntry).toBeTruthy();
+        });
+    });
+});

package/dist/src/InputPressable/InputPressable.test.js

@@ -0,0 +1,138 @@
+import React from "react";
+import { fireEvent, render, screen } from "@testing-library/react-native";
+import { InputPressable } from ".";
+const MockInputFieldWrapper = jest.fn();
+jest.mock("../InputFieldWrapper", () => (Object.assign(Object.assign({}, jest.requireActual("../InputFieldWrapper")), { InputFieldWrapper: function Mock(props) {
+        MockInputFieldWrapper(props);
+        return jest.requireActual("../InputFieldWrapper").InputFieldWrapper(props);
+    } })));
+describe("InputPressable", () => {
+    describe("InputFieldWrapper gets the expected props", () => {
+        it("renders an invalid InputPressable", () => {
+            const props = { invalid: true };
+            render(React.createElement(InputPressable, Object.assign({}, props)));
+            expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining(props));
+        });
+        it("renders an invalid InputPressable with text", () => {
+            const props = { invalid: "this test is invalid" };
+            render(React.createElement(InputPressable, Object.assign({}, props)));
+            expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining(props));
+        });
+        it("renders a valid InputText with empty string", () => {
+            const props = { invalid: "" };
+            render(React.createElement(InputPressable, Object.assign({}, props)));
+            expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining(props));
+        });
+        it("renders a disabled InputPressable", () => {
+            const props = { disabled: true };
+            render(React.createElement(InputPressable, Object.assign({}, props)));
+            expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining(props));
+        });
+        it("renders an InputPressable with a placeholder", () => {
+            const props = { placeholder: "test placeholder" };
+            render(React.createElement(InputPressable, Object.assign({}, props)));
+            expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining(props));
+        });
+    });
+    it("renders an InputPressable with a value", () => {
+        const value = "test value";
+        const { getByText } = render(React.createElement(InputPressable, { value: value }));
+        expect(getByText(value, { includeHiddenElements: true })).toBeTruthy();
+    });
+    it("renders a prefix label when specified", () => {
+        const label = "test label";
+        const { getByText } = render(React.createElement(InputPressable, { prefix: { label }, value: "hey" }));
+        expect(getByText(label)).toBeDefined();
+    });
+    it("renders a prefix icon when specified", () => {
+        const { getByTestId } = render(React.createElement(InputPressable, { prefix: { icon: "calendar" } }));
+        expect(getByTestId("calendar")).toBeDefined();
+    });
+    it("renders a suffix icon when specified", () => {
+        const { getByTestId } = render(React.createElement(InputPressable, { suffix: { icon: "calendar" } }));
+        expect(getByTestId("calendar")).toBeDefined();
+    });
+    it("calls onPress when pressed", () => {
+        const onPressMock = jest.fn();
+        const a11yLabel = "test InputPressable";
+        const { getByLabelText } = render(React.createElement(InputPressable, { onPress: onPressMock, value: "test value", accessibilityLabel: a11yLabel }));
+        fireEvent.press(getByLabelText(a11yLabel));
+        expect(onPressMock).toHaveBeenCalledTimes(1);
+    });
+    describe("when given a value", () => {
+        const value = "A value";
+        it("renders an InputPressable with the value", () => {
+            const { getByText } = render(React.createElement(InputPressable, { value: value }));
+            expect(getByText(value, { includeHiddenElements: true })).toBeDefined();
+        });
+        it("renders a prefix label when specified", () => {
+            const { getByText } = render(React.createElement(InputPressable, { prefix: { label: "test" }, value: value }));
+            expect(getByText(value, { includeHiddenElements: true })).toBeDefined();
+        });
+        it("renders a suffix label when specified", () => {
+            const { getByText } = render(React.createElement(InputPressable, { suffix: { label: "test" }, value: value }));
+            expect(getByText(value, { includeHiddenElements: true })).toBeDefined();
+        });
+    });
+    describe("showMiniLabel", () => {
+        it("defaults to true", () => {
+            const props = { placeholder: "placeholder", value: "value" };
+            render(React.createElement(InputPressable, Object.assign({}, props)));
+            expect(screen.getByText("placeholder", { includeHiddenElements: true })).toBeDefined();
+            expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining({
+                placeholderMode: "mini",
+            }));
+        });
+        describe("when true", () => {
+            it("renders the placeholder in its normal position when the input has no value", () => {
+                const props = { showMiniLabel: true, placeholder: "placeholder" };
+                render(React.createElement(InputPressable, Object.assign({}, props)));
+                expect(screen.getByText("placeholder", { includeHiddenElements: true })).toBeDefined();
+                expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining({
+                    placeholderMode: "normal",
+                }));
+            });
+            it("renders the placeholder as a mini label when the input has a value", () => {
+                const props = {
+                    showMiniLabel: true,
+                    placeholder: "placeholder",
+                    value: "value",
+                };
+                render(React.createElement(InputPressable, Object.assign({}, props)));
+                expect(screen.getByText("placeholder", { includeHiddenElements: true })).toBeDefined();
+                expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining({
+                    placeholderMode: "mini",
+                }));
+            });
+        });
+        describe("when false", () => {
+            it("renders the placeholder in its normal position when the input has no value", () => {
+                const props = { showMiniLabel: false, placeholder: "placeholder" };
+                render(React.createElement(InputPressable, Object.assign({}, props)));
+                expect(screen.getByText("placeholder", { includeHiddenElements: true })).toBeDefined();
+                expect(MockInputFieldWrapper).toHaveBeenCalledWith(expect.objectContaining({
+                    placeholderMode: "normal",
+                }));
+            });
+            it("does not render the placeholder when the input has a value", () => {
+                const props = {
+                    showMiniLabel: false,
+                    placeholder: "placeholder",
+                    value: "value",
+                };
+                render(React.createElement(InputPressable, Object.assign({}, props)));
+                expect(screen.queryByText("placeholder", { includeHiddenElements: true })).toBeNull();
+            });
+        });
+    });
+});
+describe("accessibilityLabel", () => {
+    it("uses accessibilityLabel if specified", () => {
+        const { getByLabelText } = render(React.createElement(InputPressable, { value: "test value", placeholder: "placeholder", accessibilityLabel: "accessibilityLabel" }));
+        expect(getByLabelText("accessibilityLabel")).toBeTruthy();
+    });
+    it("uses placeholder if unspecified", () => {
+        const { getByLabelText } = render(React.createElement(InputPressable, { value: "test value", placeholder: "placeholder" }));
+        expect(getByLabelText("placeholder")).toBeTruthy();
+    });
+});

package/dist/src/InputSearch/InputSearch.test.js

@@ -0,0 +1,54 @@
+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 { InputSearch } from "./InputSearch";
+const accessibilityLabelSearch = "Search";
+const accessibilityHint = "Search clients, properties, quotes, etc.";
+const mockOnChange = jest.fn();
+const mockOnDebouncedChange = jest.fn();
+let searchValue;
+beforeEach(() => {
+    mockOnChange.mockReset();
+    mockOnDebouncedChange.mockReset();
+    searchValue = "";
+});
+function setup() {
+    return render(React.createElement(InputSearch, { accessibilityHint: accessibilityHint, accessibilityLabel: accessibilityLabelSearch, placeholder: accessibilityHint, value: searchValue, onChange: mockOnChange, onDebouncedChange: mockOnDebouncedChange }));
+}
+describe("InputSearch", () => {
+    it("renders the search input text", () => {
+        const { getByHintText, getByLabelText } = setup();
+        expect(getByLabelText(accessibilityLabelSearch)).toBeDefined();
+        expect(getByHintText(accessibilityHint)).toBeDefined();
+    });
+    it("passes the correct search value to onChange when the value changed", () => {
+        const { getByLabelText } = setup();
+        const inputSearch = getByLabelText(accessibilityLabelSearch);
+        fireEvent.changeText(inputSearch, "Apollo Client");
+        expect(mockOnChange).toHaveBeenCalledWith("Apollo Client");
+    });
+    it("passes the correcet search value to onDebouncedChange when the value changed", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { getByLabelText } = setup();
+        const inputSearch = getByLabelText(accessibilityLabelSearch);
+        yield waitFor(() => {
+            fireEvent.changeText(inputSearch, "Update Apollo Client");
+            expect(mockOnDebouncedChange).toHaveBeenCalled();
+        });
+    }));
+    it("clears the search value when the clear button is pressed", () => {
+        searchValue = "test search value";
+        const { getByLabelText } = setup();
+        fireEvent(getByLabelText(accessibilityLabelSearch), "focus");
+        const inputSearchClearButton = getByLabelText("Clear input");
+        fireEvent.press(inputSearchClearButton);
+        expect(mockOnChange).toHaveBeenCalledWith("");
+    });
+});