---
# System prepended metadata

title: PID-1177

---

Composing unit tests for React Native components entails the utilization of testing libraries such as Jest and React Testing Library (RTL) or Enzyme, contingent on your personal preference. Below, I will illustrate an example of how to craft unit tests for a basic React Native component, employing Jest and RTL. In this instance, we will generate a unit test for a Button component.
Assumptions: You have a React Native project set up with Jest and RTL.

Here's how you can write unit tests for a React Native component:
1. Install Testing Libraries: Ensure that you have Jest and React Testing Library installed in your project. You can install them using npm or yarn [1][2][6].
    ```bash
    npm install --save-dev @testing-library/react-native @testing-library/jest-native
    ```
2. Write the Component: Create the React Native component you want to test. For example, create a `Button.js` component:
    ```javascript
    import React from 'react';
    import { TouchableOpacity, Text } from 'react-native';

    const Button = ({ onPress, title }) => {
      return (
        <TouchableOpacity onPress={onPress}>
          <Text>{title}</Text>
        </TouchableOpacity>
      );
    };

    export default Button;
    ```
3. Write the Unit Test: Create a test file (e.g., Button.test.js) for your component, and write unit tests for it [1][3][4][5]:
    ```javascript
    import React from 'react';
    import { render, fireEvent } from '@testing-library/react-native';
    import Button from './Button';

    describe('Button Component', () => {
      it('renders the button with the correct title', () => {
        const { getByText } = render(<Button title="Click Me" />);
        const button = getByText('Click Me');
        expect(button).toBeTruthy();
      });

      it('calls the onPress function when clicked', () => {
        const onPress = jest.fn();
        const { getByText } = render(<Button title="Click Me" onPress={onPress} />);
        const button = getByText('Click Me');
        fireEvent.press(button);
        expect(onPress).toHaveBeenCalled();
      });
    });
    ```
    In this example, we have two test cases. The first one checks if the button renders with the correct title, and the second one verifies that the onPress function is called when the button is clicked.
4. Run the Tests: Run your unit tests using Jest [1][2][6]:
    ```bash
    npm test
    ```
5. Write More Test Cases: Repeat Step 3 to write additional test cases that cover various aspects of your component's behavior. Test different props, states, and user interactions as needed.
6. Mock Dependencies (if necessary): If your component relies on external dependencies or APIs, consider mocking them using Jest's mocking features to isolate your tests from external factors.
7. Refactor and Maintain Tests: As your component evolves, remember to update and maintain your tests accordingly. Refactor your tests when necessary to keep them in sync with your component's code changes.

Jest will automatically locate and run your test files, and you will observe the test results in your console. This serves as a fundamental illustration of how to create unit tests for a React Native component. You can extend this methodology to test more intricate components, manage different props, and simulate a range of user interactions as necessary.