Blog

Pruebas en React Native con React Query y Zustand

30 de abril de 2022 12 min de lectura

Guía completa para probar aplicaciones de React Native que usan React Query para obtener datos y Zustand para la gestión de estado. Aprende buenas prácticas y estrategias de pruebas.

Pruebas en React Native con React Query y Zustand
React NativePruebasReact QueryZustandGestión de estado

React Native se ha convertido en una opción popular para construir aplicaciones móviles gracias a su ciclo de desarrollo rápido y su compatibilidad multiplataforma. Para sacar el máximo partido al desarrollo con React Native, los desarrolladores suelen recurrir a librerías de terceros como React Query y Zustand para la obtención de datos y la gestión de estado. React Query ofrece una forma flexible y eficiente de obtener, cachear y gestionar tus datos, mientras que Zustand hace que la gestión de estado sea simple y potente gracias a su enfoque minimalista.

En este artículo veremos cómo probar de forma eficaz aplicaciones de React Native que usan estas dos librerías. Usaremos como ejemplo una app de tienda sencilla y daremos ejemplos completos y detallados para ayudarte a entender el proceso de pruebas. Al final del artículo, entenderás bien cómo usar y probar React Query y Zustand en tus apps de React Native.

1. Configurar el entorno

Usaremos la versión 0.71.2 de React Native para inicializar nuestra app de tienda, la versión 3.39.3 de React Query (TanStack Query) y la versión 4.3.2 de Zustand para la obtención de datos y la gestión de estado. Compartiré el código fuente completo de la app en GitHub, así que si quieres lanzarte y verla en acción, puedes hacerlo usando el enlace que comparto al final del artículo. Así podrás seguir los ejemplos y ver el código completo de la app.

1.1. Configurar la API de la tienda

Usaremos https://fakestoreapi.com como API para mostrar técnicas de pruebas eficaces en React Native. Nuestra app de tienda obtendrá un conjunto de productos de esta API y ofrecerá una vista detallada de cada producto. Aunque FakeStoreProduct tiene otras APIs REST que podríamos usar, hacerlo aumentaría la complejidad y nos desviaría del objetivo principal de este artículo.

Para comunicarnos con nuestra API en toda la app, crearemos una instancia de axios.

1.2. Configurar la instancia de axios

import axios from "axios";

export const BASE_URL = "https://fakestoreapi.com";

export const api = axios.create({
  baseURL: BASE_URL,
});

Los siguientes pasos serán crear la configuración de react-query para nuestra API.

1.3. Crear la key factory para gestionar la caché de las queries

¿Qué es una key factory?

En esencia, TanStack Query gestiona la caché de las queries por ti basándose en las query keys. Las query keys tienen que ser un Array en el nivel superior, y pueden ser tan simples como un Array con un único string o tan complejas como un array de muchos strings y objetos anidados. ¡Mientras la query key sea serializable y única para los datos de la query, puedes usarla!

Aunque la sencillez de nuestra app no requiere necesariamente usar caché, aprovecharemos igualmente las potentes funciones de caché de React Query. Por eso crearemos una key factory sencilla, que se muestra a continuación.

export const productKeyFactory = {
  products: ["all-products"],
  productById: (id: number) => [...productKeyFactory.products, id],
} as const;

1.4. Obtener productos con react-query

import { AxiosError } from "axios";
import { useQuery, UseQueryOptions } from "react-query";
import { api } from "../axios.instance";
import { productKeyFactory } from "./key-factory";
import { Product } from "./types";

export const getAllProducts = async () => {
  return (await api.get<Array<Product>>("/products")).data;
};

export const useGetAllProducts = (
  options?: UseQueryOptions<
    Array<Product>,
    AxiosError,
    Array<Product>,
    readonly [string]
  >
) => {
  return useQuery({
    queryKey: [...productKeyFactory.products],
    queryFn: getAllProducts,
    ...options,
  });
};

Arriba hemos creado el hook useGetAllProducts para obtener los productos, usando además la query key que creamos en la sección anterior.

1.5. Obtener el detalle de un producto con react-query

import { AxiosError } from "axios";
import { useQuery, UseQueryOptions } from "react-query";
import { api } from "../axios.instance";
import { productKeyFactory } from "./key-factory";
import { Product } from "./types";

export const getProductById = async (productId: number) => {
  return (await api.get<Product>(`/products/${productId}`)).data;
};

export const useGetProductById = (
  productId: number,
  options?: UseQueryOptions<
    Product,
    AxiosError,
    Product,
    readonly (string | number)[]
  >
) => {
  return useQuery({
    queryFn: () => getProductById(productId),
    queryKey: [...productKeyFactory.productById(productId)],
    ...options,
  });
};

Casi igual que el hook anterior, salvo que esta vez el hook useGetProductById se usará para obtener el detalle del producto por su id.

1.6. El tipo Product

No nos saltemos esto: veamos qué aspecto tiene el objeto producto.

export interface Product {
  id: number;
  title: string;
  price: number;
  description: string;
  category: string;
  image: string;
  rating: Rating;
}

export interface Rating {
  rate: number;
  count: number;
}

1.7. Llega zustand: gestionar los productos de la cesta

La app incluirá funciones básicas que permiten a los usuarios añadir o quitar productos de su cesta, así como ajustar la cantidad de cada producto. Además, los usuarios pueden vaciar toda la cesta. Estas funcionalidades se gestionarán con Zustand. A continuación veremos su implementación.

import { create } from "zustand";
import { shallow } from "zustand/shallow";
import { Product } from "../api/product";

export type ProductInBasket = {
  product: Product;
  quantity: number;
};

export const updateProductQuantity = (
  productsInBasket: Array<ProductInBasket>,
  productId: number,
  updateType: "increase" | "decrease"
) => {
  return productsInBasket.map((productInBasket) => {
    if (productInBasket.product.id === productId) {
      return {
        ...productInBasket,
        quantity:
          updateType === "increase"
            ? productInBasket.quantity + 1
            : productInBasket.quantity - 1,
      };
    }
    return productInBasket;
  });
};

export const increaseProductQuantityInBasket = (
  productsInBasket: Array<ProductInBasket>,
  productId: number
) => {
  return updateProductQuantity(productsInBasket, productId, "increase");
};

export const decreaseProductQuantityInBasket = (
  productsInBasket: Array<ProductInBasket>,
  productId: number
) => {
  return updateProductQuantity(productsInBasket, productId, "decrease");
};

export interface ProductStore {
  productsInBasket: Array<ProductInBasket>;
  actions: {
    addProductToBasket: (val: Product) => void;
    removeProductFromBasket: (productId: number) => void;
    increaseProductQuantityInBasket: (productId: number) => void;
    decreaseProductQuantityInBasket: (productId: number) => void;
    resetAllProductsInBasket: () => void;
  };
}

export const useProductStore = create<ProductStore>((set, get) => ({
  productsInBasket: [],
  actions: {
    addProductToBasket: (product) =>
      set({
        productsInBasket: [
          ...get().productsInBasket,
          { product: product, quantity: 1 },
        ],
      }),
    removeProductFromBasket: (productId) =>
      set({
        productsInBasket: [
          ...get().productsInBasket.filter(
            (productInBasket) => productInBasket.product.id !== productId
          ),
        ],
      }),
    increaseProductQuantityInBasket: (productId) => {
      set({
        productsInBasket: increaseProductQuantityInBasket(
          get().productsInBasket,
          productId
        ),
      });
    },
    resetAllProductsInBasket: () => set({ productsInBasket: [] }),
    decreaseProductQuantityInBasket: (productId) => {
      set({
        productsInBasket: decreaseProductQuantityInBasket(
          get().productsInBasket,
          productId
        ),
      });
    },
  },
}));

export const useProductActions = () =>
  useProductStore((state) => state.actions);

export const useProductsInBasket = () =>
  useProductStore((state) => state.productsInBasket, shallow);
export const useProductsInBasketCount = () =>
  useProductStore((state) => state.productsInBasket.length);
export const useProductInBasketQuantityById = (productId: number | undefined) =>
  useProductStore(
    (state) =>
      state.productsInBasket.find(
        (productInBasket) => productInBasket.product.id === productId
      )?.quantity
  );

La primera parte del código define tres funciones, updateProductQuantity, increaseProductQuantityInBasket y decreaseProductQuantityInBasket, que son métodos auxiliares para actualizar la cantidad de un producto en la cesta. La función updateProductQuantity recibe como entrada un array de objetos que corresponde a productsInBasket, un ID de producto y un tipo de actualización (increase o decrease), y devuelve un nuevo array productsInBasket con la cantidad actualizada del producto indicado.

La interfaz ProductStore define el esquema del store de productos. Contiene dos propiedades:

  1. productsInBasket es un array de objetos ProductInBasket que representan los productos de la cesta.

  2. actions es un objeto que contiene funciones para gestionar los productos de la cesta, como añadir un producto, quitar un producto, aumentar o disminuir su cantidad y vaciar la cesta.

El hook useProductStore se crea con la función create de Zustand. Devuelve el store de productos con su estado y sus acciones.

Los hooks restantes, useProductActions, useProductsInBasket, useProductsInBasketCount y useProductInBasketQuantityById, son selectores derivados del hook useProductStore. Permiten acceder a partes concretas del store de productos, como las acciones o el número de productos marcados como favoritos.

Por otro lado, vale la pena mencionar que usamos shallow de zustand en useProductsInBasket. Esto se debe a que el array de objetos que devolverá useProductsInBasket provocará un rerender, ya que no son tipos primitivos, así que simplemente le decimos a zustand que queremos que el objeto se compare de forma superficial pasándole la función de igualdad shallow.

1.8. Instalar los paquetes necesarios para las pruebas

Ahora podemos pasar a la parte que más nos interesa: las pruebas. Usaremos los siguientes paquetes:

Para ser breves y no alargar el artículo, omitiremos algunos pasos de la configuración del entorno de pruebas, como jest.config.js y ts-jest.

Si quieres ver cómo acabamos configurando el entorno de pruebas, puedes consultar el enlace al código fuente completo que está disponible al final del artículo.

1.9. Simular los datos de la API con MSW

Para probar nuestra app de forma eficaz con react-query, necesitamos simular nuestra API. Para ello usaremos Mock Service Worker (MSW).

import { rest } from "msw";
import { setupServer } from "msw/node";
import { BASE_URL } from "../../src/api/axios.instance";
import {
  GET_ALL_PRODUCTS_MOCK_RESPONSE,
  GET_PRODUCT_BY_ID_MOCK_RESPONSE,
} from "./mock-data";

const getAllProductsUrl = BASE_URL + "/products";
const getProductByIdUrl = BASE_URL + `/products/:id`;

const getAllProductsHandler = rest.get(getAllProductsUrl, (_req, res, ctx) => {
  return res(ctx.status(200), ctx.json(GET_ALL_PRODUCTS_MOCK_RESPONSE));
});

const getProductByIdHandler = rest.get(getProductByIdUrl, (_req, res, ctx) => {
  return res(ctx.status(200), ctx.json(GET_PRODUCT_BY_ID_MOCK_RESPONSE));
});

const handlers = [getAllProductsHandler, getProductByIdHandler];

export const mswServer = setupServer(...handlers);

const getAllProductsFailedHandler = rest.get(
  getAllProductsUrl,
  (_req, res, ctx) => {
    return res(ctx.status(500));
  }
);

const getProductByIdFailedHandler = rest.get(
  getProductByIdUrl,
  (_req, res, ctx) => {
    return res(ctx.status(500));
  }
);

export const setupGetAllProductsFailedHandler = () =>
  mswServer.use(getAllProductsFailedHandler);

export const setupGetProductByIdFailedHandler = () =>
  mswServer.use(getProductByIdFailedHandler);

En el código anterior importamos los módulos necesarios y configuramos los handlers de MSW. Creamos dos endpoints simulados, uno para obtener todos los productos y otro para obtener un producto por su id, y ambos devuelven una respuesta correcta. Para que las pruebas sean completas, también creamos handlers que fallan para estos dos endpoints, con el fin de simular y probar escenarios de error.

Para completar la configuración de los mocks anterior, necesitamos usar el objeto mswServer en nuestro jest.setup.js. Simplemente queremos inicializar mswServer antes de cualquier caso de prueba, restablecer los handlers después de cada caso de prueba y, al final, apagarlo.

import "react-native-gesture-handler/jestSetup";
import { mswServer } from "./__mocks__/msw/handlers";

jest.useFakeTimers();

// https://mswjs.io/docs/getting-started/integrate/node#setup

// Establish API mocking before all tests.
beforeAll(() => mswServer.listen());
// Reset any request handlers that we may add during the tests,
// so they don't affect other tests.
afterEach(() => mswServer.resetHandlers());
// Clean up after the tests are finished.
afterAll(() => mswServer.close());

// Silence the warning: Animated: `useNativeDriver` is not supported because the native animated module is missing
jest.mock("react-native/Libraries/Animated/NativeAnimatedHelper");

Ya hemos simulado nuestra API para poder usarla en las pruebas. Pero todavía no hemos terminado. También tenemos que configurar las pruebas para zustand siguiendo la documentación que ofrecen. Esto nos permitirá restablecer el estado entre pruebas cuando usemos zustand en nuestros casos de prueba.

1.10. Configurar zustand para las pruebas

// https://docs.pmnd.rs/zustand/guides/testing#resetting-state-between-tests-in-react-dom
const { create: actualCreate } = jest.requireActual("zustand"); // if using jest
import { act } from "@testing-library/react-native";

// a variable to hold reset functions for all stores declared in the app
const storeResetFns = new Set();

// when creating a store, we get its initial state, create a reset function and add it in the set
export const create = (createState) => {
  const store = actualCreate(createState);
  const initialState = store.getState();
  storeResetFns.add(() => store.setState(initialState, true));
  return store;
};

// Reset all stores after each test run
beforeEach(() => {
  act(() => storeResetFns.forEach((resetFn) => resetFn()));
});

Lo crucial aquí es poner el archivo anterior en el directorio correcto según nuestro entorno de pruebas. Como usamos jest, debemos colocar este archivo en mocks/zustand.js, tal como se describe en la documentación.

Puede que ya te sientas abrumado con tanta configuración del entorno (de pruebas), pero tenía que cubrirla igualmente, porque es el esqueleto de nuestro entorno.

Dicho esto, pasemos directamente a la sección en la que creamos la pantalla para mostrar los productos.

2. Visión general de la pantalla de lista de productos

Como dijimos antes, tendremos una pantalla para mostrar los productos. Veamos a continuación el código completo de la pantalla de lista de productos:

import { DefaultTheme } from "@react-navigation/native";
import * as React from "react";
import {
  FlatList,
  ListRenderItemInfo,
  RefreshControl,
  StyleSheet,
  Text,
  View,
} from "react-native";
import { SafeAreaView } from "react-native-safe-area-context";
import { Product, useGetAllProducts } from "../api/product";
import ProductListCard from "../components/product-list-card";
import ScreenLoading from "../components/screen-loading";
import Spacing from "../components/spacing";
import useRefreshByUser from "../hooks/useRefreshByUser";
import { RouteNames } from "../navigation/route-names";
import { ProductListScreenProps } from "../navigation/types";
import { useProductActions, useProductsInBasket } from "../store/product";
import { COMMON_STYLES } from "../theme/common-styles";

type Props = ProductListScreenProps;

const ProductListScreen: React.FC<Props> = ({ navigation }) => {
  const { data, isLoading, refetch, isError, isSuccess } = useGetAllProducts();

  const { isRefetchingByUser, refetchByUser } = useRefreshByUser(refetch);

  const { addProductToBasket, removeProductFromBasket } = useProductActions();
  const productsInBasket = useProductsInBasket();

  const onAddToBasketPress = React.useCallback(
    (product: Product) => () => {
      if (
        productsInBasket.find(
          (productInBasket) => productInBasket.product.id === product.id
        )
      ) {
        removeProductFromBasket(product.id);
      } else {
        addProductToBasket(product);
      }
    },
    [addProductToBasket, productsInBasket, removeProductFromBasket]
  );

  const onProductCardPress = React.useCallback(
    (productId: number) => () => {
      navigation.navigate(RouteNames.productDetail, { id: productId });
    },
    [navigation]
  );

  const renderItemSeparator = () => (
    <Spacing
      backgroundColor={DefaultTheme.colors.background}
      height={COMMON_STYLES.screenPadding}
    />
  );

  const getKeyExtractor = (item: Product) => item.id.toString();

  const renderItem = ({ item: product }: ListRenderItemInfo<Product>) => {
    return (
      <ProductListCard
        {...product}
        testID={`product-list-card-${product.id}`}
        basketButtonTestID={`basket-button-${product.id}`}
        isInBasket={
          typeof productsInBasket.find(
            (productInBasket) => productInBasket.product.id === product.id
          ) !== "undefined"
        }
        onAddToBasketPress={onAddToBasketPress(product)}
        onPress={onProductCardPress(product.id)}
      />
    );
  };

  if (isLoading) {
    return <ScreenLoading />;
  }

  return (
    <SafeAreaView style={COMMON_STYLES.flex} edges={["bottom"]}>
      {isError && (
        <View style={COMMON_STYLES.flexCenter}>
          <Text>An error occurred</Text>
        </View>
      )}

      {isSuccess && (
        <FlatList<Product>
          data={data}
          testID="product-list-flat-list"
          refreshControl={
            <RefreshControl
              refreshing={isRefetchingByUser}
              onRefresh={refetchByUser}
            />
          }
          renderItem={renderItem}
          numColumns={2}
          ItemSeparatorComponent={renderItemSeparator}
          columnWrapperStyle={styles.columnWrapper}
          contentContainerStyle={styles.contentContainerStyle}
          showsVerticalScrollIndicator={false}
          keyExtractor={getKeyExtractor}
          style={COMMON_STYLES.flex}
        />
      )}
    </SafeAreaView>
  );
};

export default ProductListScreen;

const styles = StyleSheet.create({
  contentContainerStyle: {
    flexGrow: 1,
    padding: COMMON_STYLES.screenPadding,
  },
  columnWrapper: {
    justifyContent: "space-between",
  },
});

Esta pantalla se encarga de lo siguiente:

  • Mostrar los productos con el hook personalizado de react-query useGetAllProducts, que creamos en la sección 1.4. Obtener productos con react-query.

  • Permitir a los usuarios añadir o quitar productos de su cesta con el hook personalizado de zustand useProductActions, que también vimos en la sección 1.7. Llega zustand: gestionar los productos de la cesta.

  • Volver a obtener los productos con pull-to-refresh.

  • Actualizar el texto de la cantidad que se muestra en el icono de la cesta, a la derecha del encabezado.

A continuación se muestra la pantalla de lista de productos:

2.1. Probar la pantalla de lista de productos

En esta sección vamos a probar la pantalla de lista de productos. Los casos de prueba iniciales que realizaremos son los siguientes:

  • Al principio debe mostrarse el indicador de carga, aunque simulemos los datos. El flag booleano isLoading de react-query seguirá valiendo true durante un breve periodo de tiempo. Después de obtener los datos, isLoading será false y el loader dejará de mostrarse.

  • La lista de productos debe mostrarse correctamente después de obtener los datos. Usaremos la prop testID del componente ProductListCard para verificar este caso.

  • Si falla la query para obtener todos los productos, la pantalla debe mostrar un mensaje de error. Usaremos el helper setupGetAllProductsFailedHandler que creamos en 1.9. Simular los datos de la API con MSW

2.1.1. Caso de prueba: debe mostrar el indicador de carga al principio

import { renderHook } from "@testing-library/react-hooks";
import { render, screen } from "@testing-library/react-native";
import React from "react";
import { useGetAllProducts } from "../../api/product";
import { createReactQueryWrapper } from "../../utils/testing";
import ProductListScreen from "../product-list";

const navigateMock = jest.fn();
const navigation = { navigate: navigateMock } as any;
const route = jest.fn() as any;

const component = <ProductListScreen navigation={navigation} route={route} />;

describe("Product list screen", () => {
  it("should display loading indicator initially", async () => {
    // We render the component and expect to see a loading indicator
    render(component, { wrapper: createReactQueryWrapper });
    expect(screen.queryByTestId(`screen-loader`)).toBeTruthy();

    // We render the product list using useGetAllProducts hook and wait until the products are loaded
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });
    await waitFor(() => result.current.isSuccess);

    // We expect the loading indicator to disappear after the products are loaded
    expect(screen.queryByTestId(`screen-loader`)).not.toBeTruthy();
  });
});

Al principio del archivo importamos los módulos necesarios para ejecutar nuestras pruebas. Luego creamos una variable llamada component para guardar nuestra pantalla de lista de productos, de modo que podamos reutilizarla en todos nuestros casos de prueba. Además, como es una pantalla y declaramos sus props en la sección 2. Visión general de la pantalla de lista de productos, en la línea 22 también tenemos que proporcionar las props de pantalla necesarias, navigation y route. En los próximos casos de prueba volveremos a por qué desestructuramos el objeto navigation arriba.

Un breve repaso de la terminología que debemos tener en cuenta para entender los casos de prueba:

  • render: renderiza en profundidad el elemento de React dado y devuelve helpers para consultar la estructura de los componentes resultantes.

  • screen: guarda el valor de la última llamada a render para acceder más fácilmente a las queries y otras funciones que devuelve render.

  • renderHook: renderiza un componente de prueba que llamará al callback proporcionado, incluidos los hooks a los que llame, cada vez que se renderice.

    Como el objetivo principal de este artículo es dar pautas sobre cómo hacer pruebas, y no presentar las librerías de pruebas y sus funciones, no entraremos en detalle sobre ellas. De todos modos, a lo largo del artículo tendremos suficientes ejemplos para ver cómo se usan.

El caso de prueba anterior comprueba si al principio se muestra en pantalla un componente de carga. La función render renderiza el componente ProductListScreen envuelto en la función createReactQueryWrapper, una función de utilidad sencilla que se usa para crear el QueryClientProvider. La función screen.queryByTestId() comprueba si el loader se muestra en pantalla.

La función renderHook se usa para probar el hook useGetAllProducts, que el componente ProductListScreen usa para obtener los datos de los productos. La opción wrapper se pasa a la función renderHook para envolver el hook useGetAllProducts en la función createReactQueryWrapper. La variable result contiene el valor que devuelve el hook useGetAllProducts. Mientras tanto, la función waitFor espera hasta que la propiedad isSuccess del objeto result sea true, lo que significa que los datos de los productos se han obtenido correctamente.

La segunda parte comprueba que el componente de carga deja de mostrarse después de obtener correctamente los datos de los productos.

Usamos queryByTestId en lugar de getByTestId porque sabemos que el componente de carga no será visible después de obtener los datos, así que getByTestId lanzaría un error.

Si usáramos getByTestId, el error que podríamos encontrarnos sería el siguiente:

2.1.2. Caso de prueba: debe mostrar correctamente los datos de la lista de productos

import { renderHook } from "@testing-library/react-hooks";
import { render, screen } from "@testing-library/react-native";
import React from "react";
import { useGetAllProducts } from "../../api/product";
import { createReactQueryWrapper } from "../../utils/testing";
import ProductListScreen from "../product-list";

const navigateMock = jest.fn();
const navigation = { navigate: navigateMock } as any;
const route = jest.fn() as any;

const component = <ProductListScreen navigation={navigation} route={route} />;

describe("Product list screen", () => {
  it("should display product list data correctly", async () => {
    // Render the component and wait for it to load
    render(component, { wrapper: createReactQueryWrapper });

    // Check that no product card is rendered before fetching data
    expect(screen.queryByTestId(`product-list-card-1`)).not.toBeTruthy();

    // Fetch the product data
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // Wait for the data to be fetched successfully
    await waitFor(() => result.current.isSuccess);

    // Check that each product card is rendered for each product in the data
    for (const { id } of result.current.data!) {
      expect(screen.queryByTestId(`product-list-card-${id}`)).toBeTruthy();
    }
  });
});

Este código de prueba comprueba si la pantalla de lista de productos muestra correctamente los datos de productos obtenidos.

Esta vez volvemos a esperar a que los datos se obtengan correctamente y luego nos aseguramos de que los datos de la lista de productos se muestran bien recorriendo los datos obtenidos y esperando que exista una tarjeta de producto con el testID product-list-card-${id} para cada producto de los datos. La propiedad id se genera dinámicamente a partir del ID del producto. Si la prueba falla, significa que los elementos de la lista de productos no están mostrando bien los datos.

Fíjate en cómo usábamos la función renderItem para renderizar los elementos de la lista, como se ve abajo. Recorremos product.id y lo combinamos con el string product-list-card para generar un testID dinámico para el componente ProductListCard. Así podremos probar todos los productos junto con su respectiva prop testID.

const renderItem = ({ item: product }: ListRenderItemInfo<Product>) => {
  return (
    <ProductListCard
      {...product}
      testID={`product-list-card-${product.id}`}
      basketButtonTestID={`basket-button-${product.id}`}
      isInBasket={
        typeof productsInBasket.find(
          (productInBasket) => productInBasket.product.id === product.id
        ) !== "undefined"
      }
      onAddToBasketPress={onAddToBasketPress(product)}
      onPress={onProductCardPress(product.id)}
    />
  );
};

2.1.3. Caso de prueba: debe mostrar un texto de error si falla la query para obtener todos los productos

En este caso de prueba, probamos el escenario en el que falla la llamada a la API para obtener todos los productos.

import { renderHook } from "@testing-library/react-hooks";
import { render, screen } from "@testing-library/react-native";
import React from "react";
import { setupGetAllProductsFailedHandler } from "../../../__mocks__/msw/handlers";
import { useGetAllProducts } from "../../api/product";
import { createReactQueryWrapper } from "../../utils/testing";
import ProductListScreen from "../product-list";

const navigateMock = jest.fn();
const navigation = { navigate: navigateMock } as any;
const route = jest.fn() as any;

const component = <ProductListScreen navigation={navigation} route={route} />;

describe("Product list screen", () => {
  it("should display error text in case get all products query fails", async () => {
    // Set up the mock handler for GET requests to the /products endpoint that returns an error response
    setupGetAllProductsFailedHandler();

    // Render the ProductListScreen component wrapped in the React Query wrapper
    render(component, { wrapper: createReactQueryWrapper });

    // Set up a mock React hook that calls the useGetAllProducts hook from the API module
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // Wait for the useGetAllProducts hook to throw an error
    await waitFor(() => result.current.isError);

    // Assert that the "An error occurred" text is displayed on the screen
    expect(screen.getByText(`An error occurred`)).toBeTruthy();
  });
});

Para simular el fallo de la API, usamos la función setupGetAllProductsFailedHandler del mock service worker (msw), que implementamos en la sección 1.9. Simular los datos de la API con MSW, en la línea 38. Después renderizamos el componente ProductListScreen con la función render e invocamos con la función renderHook el hook useGetAllProducts, que obtiene los datos.

Usamos la función waitFor de @testing-library/react-hooks para esperar a que la propiedad isError del objeto result.current sea true. Así nos aseguramos de que el hook ha terminado de ejecutarse y de que la llamada a la API ha fallado. Por último, comprobamos que se mostrará en pantalla el mensaje de error "An error occurred" (puedes confirmarlo mirando el código fuente de la pantalla de lista de productos), verificando que el texto está presente con la función getByText de @testing-library/react-native.

2.1.4. Caso de prueba: debe llamar a la acción de navegación al pulsar el primer producto

Vamos a probar el siguiente fragmento de código, que en realidad está extraído de nuestra pantalla de lista de productos. Este código se encarga de gestionar la pulsación del usuario sobre cualquiera de las tarjetas de producto de la lista.

const onProductCardPress = React.useCallback(
  (productId: number) => () => {
    navigation.navigate(RouteNames.productDetail, { id: productId });
  },
  [navigation]
);

const renderItem = ({ item: product }: ListRenderItemInfo<Product>) => {
  return (
    <ProductListCard
      {...product}
      testID={`product-list-card-${product.id}`}
      basketButtonTestID={`basket-button-${product.id}`}
      isInBasket={
        typeof productsInBasket.find(
          (productInBasket) => productInBasket.product.id === product.id
        ) !== "undefined"
      }
      onAddToBasketPress={onAddToBasketPress(product)}
      onPress={onProductCardPress(product.id)}
    />
  );
};

Veamos a continuación cómo podemos abordar su prueba:

import { renderHook } from "@testing-library/react-hooks";
import { fireEvent, render, screen } from "@testing-library/react-native";
import React from "react";
import { useGetAllProducts } from "../../api/product";
import { RouteNames } from "../../navigation/route-names";
import { createReactQueryWrapper } from "../../utils/testing";
import ProductListScreen from "../product-list";

const navigateMock = jest.fn();
const navigation = { navigate: navigateMock } as any;
const route = jest.fn() as any;

const component = <ProductListScreen navigation={navigation} route={route} />;

describe("Product list screen", () => {
  it("should call navigation action on pressing the first product item", async () => {
    // render ProductListScreen component with createReactQueryWrapper as a wrapper
    render(component, { wrapper: createReactQueryWrapper });

    // render hook for useGetAllProducts with createReactQueryWrapper as a wrapper
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // wait for useGetAllProducts to succeed
    await waitFor(() => result.current.isSuccess);

    // find first product item and simulate a press event on it
    const firstProductItem = screen.getByTestId(`product-list-card-1`);
    fireEvent.press(firstProductItem);

    // assert that navigation action was called with correct route name and params
    expect(navigateMock).toHaveBeenCalledWith(RouteNames.productDetail, {
      id: 1,
    });
  });
});

En este fragmento de prueba comprobamos si se llama a la acción de navegación al pulsar un producto. Primero renderizamos el componente ProductListScreen y esperamos a que los datos se obtengan correctamente, igual que en los casos de prueba anteriores. Después obtenemos el primer producto de la lista y simulamos una pulsación sobre él con fireEvent.press. Por último, esperamos que la función navigate del objeto navigation se haya llamado con los parámetros RouteName y productId esperados.

2.1.5. Caso de prueba: debe añadir y quitar correctamente un producto al pulsar el icono de la cesta del producto

El siguiente caso de prueba comprueba el escenario en el que el usuario añade y quita un producto de la cesta pulsando el icono de la cesta en la tarjeta del producto, en la pantalla Product List.

import { NavigationContainer } from "@react-navigation/native";
import { renderHook } from "@testing-library/react-hooks";
import { fireEvent, render, screen } from "@testing-library/react-native";
import React from "react";
import { useGetAllProducts } from "../../api/product";
import ProductStack from "../../navigation/product-stack";
import { useProductStore } from "../../store/product";
import { createReactQueryWrapper } from "../../utils/testing";

// We render the whole app stack instead of rendering just the screen
// because we need access to the react-navigation's header, which wouldn't
// be possible if we just rendered the screen.
const rootAppComponent = (
  <NavigationContainer>
    <ProductStack />
  </NavigationContainer>
);

describe("Product list screen", () => {
  it("should add/remove product item correctly on pressing product items basket icon", async () => {
    // We render the entire app stack and use the createReactQueryWrapper as a
    // wrapper for the render function to set up the React Query Provider.
    render(rootAppComponent, {
      wrapper: createReactQueryWrapper,
    });

    // We use the renderHook function to invoke the useGetAllProducts hook which
    // fetches the data.
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // We use the renderHook function to get access to the useProductStore hook
    // which we will use to check that the products in the basket were added/removed correctly.
    const { result: productStore } = renderHook(() => useProductStore(), {
      wrapper: createReactQueryWrapper,
    });

    // We wait for the useGetAllProducts hook to complete fetching the data before proceeding
    // with the test.
    await waitFor(() => result.current.isSuccess);

    // We get the basket button for the first product item using the getByTestId function.
    const firstProductItemBasketButton = screen.getByTestId(`basket-button-1`);

    // We click the basket button for the first product item.
    fireEvent.press(firstProductItemBasketButton);

    // We check that the basket icon quantity text is present using the getByTestId function.
    expect(screen.getByTestId("basket-icon-quantity-text-1")).toBeTruthy();

    // We check that the products in the basket have been added correctly using the productStore.
    expect(productStore.current.productsInBasket).toHaveLength(1);
    expect(productStore.current.productsInBasket[0].quantity).toBe(1);
    expect(productStore.current.productsInBasket[0].product).toMatchObject(
      result.current.data![0]
    );

    // We click the basket button for the first product item again to remove it from the basket.
    fireEvent.press(firstProductItemBasketButton);

    // We check that the basket icon quantity text is not present.
    expect(
      screen.queryByTestId("basket-icon-quantity-text-1")
    ).not.toBeTruthy();

    // We check that the products in the basket have been removed correctly using the productStore.
    expect(productStore.current.productsInBasket).toHaveLength(0);
  });
});

Para probar la funcionalidad del icono de la cesta en el encabezado, necesitamos renderizar todo el ProductStack además de ProductListScreen. Esto se debe a que necesitamos acceder al encabezado de la pantalla Product List para obtener el icono de la cesta por su test ID. Para ello tenemos que renderizar todo el ProductStack, junto con el NavigationContainer.

Una vez obtenidos correctamente los productos, usamos fireEvent.press para simular la pulsación del icono de la cesta en el primer producto, lo que añade el producto a la cesta. Después comprobamos que el icono de la cesta muestra la cantidad correcta y que el producto se ha añadido al array productsInBasket del store de productos con la cantidad y el objeto de producto correctos.

Luego simulamos otra pulsación del icono de la cesta para quitar el producto de la cesta, y comprobamos que el icono ya no muestra la cantidad y que el array productsInBasket del store de productos está vacío.

En resumen, este caso de prueba comprueba la funcionalidad de añadir y quitar un producto de la cesta, así como de ajustar sus cantidades pulsando el icono de la cesta en la tarjeta del producto en la pantalla Product List, y confirma que el store de productos gestiona correctamente los productos y sus cantidades en la cesta.

2.1.6. Flujo de pruebas completo de la pantalla de lista de productos

El flujo de pruebas completo de la pantalla de lista de productos es el siguiente:

import { NavigationContainer } from "@react-navigation/native";
import { renderHook } from "@testing-library/react-hooks";
import { fireEvent, render, screen } from "@testing-library/react-native";
import React from "react";
import { setupGetAllProductsFailedHandler } from "../../../__mocks__/msw/handlers";
import { useGetAllProducts } from "../../api/product";
import ProductStack from "../../navigation/product-stack";
import { RouteNames } from "../../navigation/route-names";
import { useProductStore } from "../../store/product";
import { createReactQueryWrapper } from "../../utils/testing";
import ProductListScreen from "../product-list";

// We render the whole app stack instead of rendering just the screen
// because we need access to the react-navigation's header, which wouldn't
// be possible if we just rendered the screen.
const rootAppComponent = (
  <NavigationContainer>
    <ProductStack />
  </NavigationContainer>
);
const navigateMock = jest.fn();
const navigation = { navigate: navigateMock } as any;
const route = jest.fn() as any;

const component = <ProductListScreen navigation={navigation} route={route} />;

describe("Product list screen", () => {
  it("should display loading indicator initially", async () => {
    // We render the component and expect to see a loading indicator
    render(component, { wrapper: createReactQueryWrapper });
    expect(screen.queryByTestId(`screen-loader`)).toBeTruthy();

    // We render the product list using useGetAllProducts hook and wait until the products are loaded
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });
    await waitFor(() => result.current.isSuccess);

    // We expect the loading indicator to disappear after the products are loaded
    expect(screen.queryByTestId(`screen-loader`)).not.toBeTruthy();
  });

  it("should display product list data correctly", async () => {
    // Render the component and wait for it to load
    render(component, { wrapper: createReactQueryWrapper });

    // Check that no product card is rendered before fetching data
    expect(screen.queryByTestId(`product-list-card-1`)).not.toBeTruthy();

    // Fetch the product data
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // Wait for the data to be fetched successfully
    await waitFor(() => result.current.isSuccess);

    // Check that each product card is rendered for each product in the data
    for (const { id } of result.current.data!) {
      expect(screen.queryByTestId(`product-list-card-${id}`)).toBeTruthy();
    }
  });

  it("should display error text in case get all products query fails", async () => {
    // Set up the mock handler for GET requests to the /products endpoint that returns an error response
    setupGetAllProductsFailedHandler();

    // Render the ProductListScreen component wrapped in the React Query wrapper
    render(component, { wrapper: createReactQueryWrapper });

    // Set up a mock React hook that calls the useGetAllProducts hook from the API module
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // Wait for the useGetAllProducts hook to throw an error
    await waitFor(() => result.current.isError);

    // Assert that the "An error occurred" text is displayed on the screen
    expect(screen.getByText(`An error occurred`)).toBeTruthy();
  });

  it("should call navigation action on pressing the first product item", async () => {
    // Render the ProductListScreen component along with react-query wrapper
    render(component, { wrapper: createReactQueryWrapper });

    // Render the useGetAllProducts hook with react-query wrapper to fetch data
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // Wait for the data to be fetched
    await waitFor(() => result.current.isSuccess);

    // Find the first product card in the list and simulate a press event on it
    const firstProductItem = screen.getByTestId(`product-list-card-1`);
    fireEvent.press(firstProductItem);

    // Expect that the navigation function is called with the correct route name and params
    expect(navigateMock).toHaveBeenCalledWith(RouteNames.productDetail, {
      id: 1,
    });
  });

  it("should add/remove product item correctly on pressing product items basket icon", async () => {
    // We render the entire app stack and use the createReactQueryWrapper as a
    // wrapper for the render function to set up the React Query Provider.
    render(rootAppComponent, {
      wrapper: createReactQueryWrapper,
    });

    // We use the renderHook function to invoke the useGetAllProducts hook which
    // fetches the data.
    const { result, waitFor } = renderHook(() => useGetAllProducts(), {
      wrapper: createReactQueryWrapper,
    });

    // We use the renderHook function to get access to the useProductStore hook
    // which we will use to check that the products in the basket were added/removed correctly.
    const { result: productStore } = renderHook(() => useProductStore(), {
      wrapper: createReactQueryWrapper,
    });

    // We wait for the useGetAllProducts hook to complete fetching the data before proceeding
    // with the test.
    await waitFor(() => result.current.isSuccess);

    // We get the basket button for the first product item using the getByTestId function.
    const firstProductItemBasketButton = screen.getByTestId(`basket-button-1`);

    // We click the basket button for the first product item.
    fireEvent.press(firstProductItemBasketButton);

    // We check that the basket icon quantity text is present using the getByTestId function.
    expect(screen.getByTestId("basket-icon-quantity-text-1")).toBeTruthy();

    // We check that the products in the basket have been added correctly using the productStore.
    expect(productStore.current.productsInBasket).toHaveLength(1);
    expect(productStore.current.productsInBasket[0].quantity).toBe(1);
    expect(productStore.current.productsInBasket[0].product).toMatchObject(
      result.current.data![0]
    );

    // We click the basket button for the first product item again to remove it from the basket.
    fireEvent.press(firstProductItemBasketButton);

    // We check that the basket icon quantity text is not present.
    expect(
      screen.queryByTestId("basket-icon-quantity-text-1")
    ).not.toBeTruthy();

    // We check that the products in the basket have been removed correctly using the productStore.
    expect(productStore.current.productsInBasket).toHaveLength(0);
  });
});

Para terminar

En conclusión, este artículo ha explorado estrategias de pruebas eficaces para aplicaciones de React Native que usan las librerías React Query y Zustand, bastante populares hoy en día en cualquier aplicación de React o React Native. Usando como ejemplo una app de tienda sencilla y con ejemplos completos y detallados, hemos cubierto el proceso de pruebas y cómo garantizar la calidad del código mediante la implementación de pruebas. Puedes consultar el código fuente completo en el siguiente enlace. ¡Que tengas un buen día!

Enlace al código fuente completo

Publicado en

Este artículo también está publicado en: