React Native est devenu un choix populaire pour créer des applications mobiles, grâce à son cycle de développement rapide et à sa compatibilité multiplateforme. Pour tirer le meilleur parti de React Native, les développeurs se tournent souvent vers des bibliothèques tierces comme React-Query et Zustand pour gérer la récupération des données et le state management. React-Query offre une manière flexible et efficace de récupérer, mettre en cache et gérer vos données, tandis que Zustand rend le state management simple et puissant grâce à son approche minimaliste.
Dans cet article, nous allons voir comment tester efficacement des applications React Native qui utilisent ces deux bibliothèques. Nous prendrons comme exemple une simple application de boutique, avec des exemples complets et détaillés pour vous aider à comprendre le processus de test. À la fin de cet article, vous saurez bien comment utiliser et tester React-Query et Zustand dans vos applications React Native
1 Mettre en place l’environnement
Nous utiliserons React Native en version 0.71.2 pour initialiser notre application de boutique, ainsi que React-Query (Tanstack query) en version 3.39.3 et Zustand en version 4.3.2 pour gérer la récupération des données et le state management. Je fournirai le code source complet de l’application sur GitHub, donc si vous voulez directement la voir en action, vous pouvez utiliser le lien partagé à la fin de l’article. Vous pourrez ainsi suivre les exemples et consulter le code complet de l’application.
1.1 Mettre en place l’API de la boutique
Nous utiliserons https://fakestoreapi.com comme API pour illustrer des techniques de test efficaces en React Native. Notre application de boutique récupérera un ensemble de produits depuis cette API et affichera une vue détaillée de chaque produit. FakeStoreProduct propose d’autres API REST que nous pourrions utiliser, mais cela augmenterait la complexité et nous éloignerait de l’objectif principal de cet article.
Pour communiquer avec notre API dans toute l’application, nous allons créer une instance axios.
1.2 Configurer l’instance axios
import axios from "axios";
export const BASE_URL = "https://fakestoreapi.com";
export const api = axios.create({
baseURL: BASE_URL,
});
L’étape suivante consiste à mettre en place react-query pour notre API.
1.3 Créer la key-factory pour gérer le cache des requêtes
Qu’est-ce qu’une key-factory ?
Même si la simplicité de notre application ne nécessite pas forcément de cache, nous allons tout de même utiliser les puissantes fonctionnalités de cache de React-Query. Nous allons donc créer une key factory simple, présentée ci-dessous.
export const productKeyFactory = {
products: ["all-products"],
productById: (id: number) => [...productKeyFactory.products, id],
} as const;
1.4 Récupérer les produits avec 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,
});
};
Ci-dessus, nous avons créé le hook useGetAllProducts pour récupérer les produits, en utilisant la query-key créée dans la section précédente.
1.5 Récupérer le détail d’un produit avec 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,
});
};
C’est presque le même hook que le précédent, sauf que cette fois, le hook useGetProductById servira à récupérer le détail d’un produit à partir de son id.
1.6 Le type Product
Ne sautons pas cette étape et regardons à quoi ressemble l’objet produit.
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 Place à zustand pour gérer les produits du panier
L’application inclura des fonctionnalités de base permettant aux utilisateurs d’ajouter des produits à leur panier ou de les en retirer, ainsi que d’ajuster la quantité de chaque produit. Les utilisateurs pourront aussi vider entièrement le panier. Ces fonctionnalités seront gérées avec Zustand. Voyons son implémentation ci-dessous.
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 première partie du code définit trois fonctions, updateProductQuantity, increaseProductQuantityInBasket et decreaseProductQuantityInBasket, qui sont des méthodes helper pour mettre à jour la quantité d’un produit dans le panier. La fonction updateProductQuantity prend en entrée un tableau d’objets correspondant à productsInBasket, un ID de produit et un type de mise à jour (increase ou decrease), et renvoie un nouveau tableau productsInBasket avec la quantité mise à jour pour le produit donné.
L’interface ProductStore définit le schéma du store des produits. Elle contient deux propriétés :
-
productsInBasket est un tableau d’objets ProductInBasket représentant les produits du panier.
-
actions est un objet contenant les fonctions de gestion des produits du panier : ajouter un produit, retirer un produit, augmenter ou diminuer sa quantité et vider le panier.
Le hook useProductStore est créé avec la fonction create de Zustand. Il renvoie le store des produits avec son state et ses actions.
Les autres hooks, useProductActions, useProductsInBasket, useProductsInBasketCount et useProductInBasketQuantityById, sont des sélecteurs dérivés du hook useProductStore. Ils donnent accès à des parties précises du store des produits, comme les actions ou le nombre de produits favoris.
Par ailleurs, il faut noter que nous avons utilisé shallow de zustand dans useProductsInBasket. En effet, le tableau d’objets renvoyé par useProductsInBasket provoquerait un rerender, puisque ce ne sont pas des types primitifs*. Nous indiquons donc simplement à zustand que nous voulons une comparaison superficielle de l’objet en lui passant la fonction d’égalité shallow.
1.8 Installer les packages nécessaires aux tests
Nous pouvons maintenant passer à la partie qui nous intéresse le plus : les tests. Nous utiliserons les packages ci-dessous :
Par souci de concision et pour ne pas rallonger l’article, nous allons laisser de côté certaines étapes de configuration de l’environnement de test, comme jest.config.js et ts-jest.
N’hésitez pas à regarder comment nous avons finalement configuré l’environnement de test grâce au lien vers le code source complet, disponible à la fin de l’article.
1.9 Mocker les données de l’API avec MSW
Pour tester efficacement notre application avec react-query, nous devons mocker notre API. Pour cela, nous allons utiliser 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);
Dans le code ci-dessus, nous importons les modules nécessaires et configurons les handlers MSW. Nous créons deux endpoints mockés, l’un pour récupérer tous les produits et l’autre pour récupérer un produit par son id, qui renvoient tous deux une réponse réussie. Pour des tests complets, nous créons aussi des handlers d’échec pour ces deux endpoints, afin de simuler et tester les scénarios d’erreur.
Pour terminer la configuration du mock ci-dessus, nous devons utiliser l’objet mswServer dans notre jest.setup.js. Nous voulons simplement initialiser mswServer avant tous les cas de test, réinitialiser les handlers après chaque cas de test et, à la fin, l’arrêter.
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");
Nous avons maintenant mocké notre API pour pouvoir l’utiliser dans les tests. Mais ce n’est pas encore terminé. Nous devons aussi configurer zustand pour les tests en suivant la documentation fournie. Cela nous permettra de réinitialiser le state entre les tests quand nous utilisons zustand dans nos cas de test.
1.10 Configurer zustand pour les tests
// 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()));
});
L’essentiel ici est de placer le fichier ci-dessus dans le bon répertoire selon notre environnement de test. Comme nous utilisons jest, nous devons placer ce fichier dans mocks/zustand.js, comme indiqué dans la documentation.
Vous vous sentez peut-être déjà submergé par toute cette configuration de l’environnement (de test), mais je devais quand même la couvrir, car c’est le squelette de notre environnement.
Cela dit, passons directement à la section dans laquelle nous créons notre écran d’affichage des produits.
2 Vue d’ensemble de l’écran de liste des produits
Comme mentionné plus haut, nous aurons un écran pour afficher les produits. Voyons ci-dessous le code complet de l’écran de liste des produits :
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",
},
});
Cet écran est responsable des éléments suivants :
-
Afficher les produits avec le hook react query personnalisé useGetAllProducts, que nous avons créé dans la section 1.4 Récupérer les produits avec react-query.
-
Permettre aux utilisateurs d’ajouter des produits à leur panier ou de les en retirer avec le hook zustand personnalisé useProductActions, que nous avons aussi vu dans la section 1.7 Place à zustand pour gérer les produits du panier.
-
Recharger les produits avec le pull-to-refresh.
-
Mettre à jour le texte de quantité affiché sur l’icône du panier, à droite du header.
Voici une démonstration de l’écran de liste des produits :

2.1 Tester l’écran de liste des produits
Dans cette section, nous allons tester l’écran de liste des produits. Les premiers cas de test seront les suivants :
-
Au départ, l’indicateur de chargement doit s’afficher, même si nous mockons les données. Le flag booléen isLoading de react-query vaudra quand même true pendant un court instant. Une fois les données récupérées, isLoading passera à false et le loader ne s’affichera plus.
-
La liste des produits doit s’afficher correctement une fois les données récupérées. Nous utiliserons la prop testID du composant ProductListCard pour vérifier ce cas.
-
Si la requête de récupération de tous les produits échoue, l’écran doit afficher un message d’erreur. Nous utiliserons le helper setupGetAllProductsFailedHandler créé dans 1.9 Mocker les données de l’API avec MSW
2.1.1 Cas de test : il doit afficher l’indicateur de chargement au départ
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();
});
});
En haut du fichier, nous avons importé les modules nécessaires à l’exécution de nos tests. Nous avons ensuite créé une variable appelée component pour stocker notre écran de liste des produits, afin de pouvoir la réutiliser dans tous nos cas de test. De plus, comme il s’agit d’un écran, et que nous avons déclaré les props de l’écran dans la section 2 Vue d’ensemble de l’écran de liste des produits, à la ligne 22, nous devons aussi fournir les props requises de l’écran, navigation et route. Nous verrons dans les prochains cas de test pourquoi nous avons déstructuré l’objet navigation ci-dessus.
Un petit rappel de la terminologie à connaître pour comprendre les cas de test :
-
render : effectue un rendu complet de l’élément React donné et renvoie des helpers pour interroger la structure des composants produits.
-
screen : contient la valeur du dernier appel à render, pour accéder plus facilement aux requêtes et aux autres fonctions renvoyées par render.
-
renderHook : effectue le rendu d’un composant de test qui appellera le callback fourni, y compris les hooks qu’il appelle, à chaque rendu.
Comme l’objectif principal de cet article est d’expliquer comment tester, et non de présenter les bibliothèques de test et leurs fonctions, nous n’entrerons pas dans les détails. Nous aurons de toute façon assez d’exemples tout au long de l’article pour voir comment elles s’utilisent.
Le cas de test ci-dessus vérifie qu’un composant de chargement d’écran s’affiche au départ. La fonction render affiche le composant ProductListScreen enveloppé dans la fonction createReactQueryWrapper, une simple fonction utilitaire qui sert à créer un QueryClientProvider. La fonction screen.queryByTestId() vérifie si le loader est affiché à l’écran.
La fonction renderHook sert à tester le hook useGetAllProducts, utilisé dans le composant ProductListScreen pour récupérer les données des produits. L’option wrapper est passée à la fonction renderHook pour envelopper le hook useGetAllProducts dans la fonction createReactQueryWrapper. La variable result contient la valeur renvoyée par le hook useGetAllProducts. La fonction waitFor, elle, attend que la propriété isSuccess de l’objet result soit à true, ce qui signifie que les données des produits ont bien été récupérées.
La seconde partie vérifie que le composant de chargement n’est plus affiché une fois les données des produits récupérées avec succès.
Nous avons utilisé queryByTestId plutôt que getByTestId parce que nous savons que le composant de chargement ne sera plus visible une fois les données récupérées, et getByTestId lèverait donc une erreur.
Voici l’erreur que nous obtiendrions en utilisant getByTestId :

2.1.2 Cas de test : il doit afficher correctement les données de la liste des produits
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();
}
});
});
Ce code teste si l’écran de liste des produits affiche correctement les données des produits récupérées.
Cette fois encore, nous attendons que les données soient récupérées avec succès, puis nous vérifions que la liste des produits s’affiche correctement en parcourant les données récupérées et en nous attendant à ce qu’une carte de produit avec le testID product-list-card-${id} existe pour chaque produit. La propriété id est générée dynamiquement à partir de l’ID du produit. Si le test échoue, cela signifie que les éléments de la liste n’affichent pas correctement les données des produits.
Remarquez ci-dessous comment nous utilisions la fonction renderItem pour afficher les éléments de la liste. Nous parcourons product.id et le combinons avec la chaîne product-list-card pour générer un testID dynamique pour le composant ProductListCard. De cette façon, nous pouvons tester tous les produits avec leur prop testID respective.
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 Cas de test : il doit afficher un texte d’erreur si la requête de récupération de tous les produits échoue
Dans ce cas de test, nous testons le scénario où l’appel API qui récupère tous les produits échoue.
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();
});
});
Pour simuler l’échec de l’API, nous utilisons la fonction setupGetAllProductsFailedHandler du mock service worker (msw), que nous avons implémentée dans la section 1.9 Mocker les données de l’API avec MSW, à la ligne 38. Nous affichons ensuite le composant ProductListScreen avec la fonction render, et nous appelons avec la fonction renderHook le hook useGetAllProducts, qui récupère les données.
Nous utilisons la fonction waitFor de @testing-library/react-hooks pour attendre que la propriété isError de l’objet result.current passe à true. Cela garantit que le hook a fini de s’exécuter et que l’appel API a échoué. Enfin, nous vérifions que le message d’erreur « An error occurred » (vous pouvez le confirmer en consultant le code source de l’écran de liste des produits) s’affiche à l’écran, en contrôlant la présence du texte avec la fonction getByText de @testing-library/react-native.
2.1.4 Cas de test : il doit appeler l’action de navigation lors de l’appui sur le premier produit
Nous allons tester l’extrait de code suivant, tiré de notre écran de liste des produits. Ce code gère l’appui de l’utilisateur sur n’importe quelle carte de produit de la liste.
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)}
/>
);
};
Voyons ci-dessous comment aborder ce test :
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,
});
});
});
Dans cet extrait de test, nous vérifions que l’action de navigation est appelée quand on appuie sur un produit. D’abord, nous affichons le composant ProductListScreen et attendons que les données soient récupérées avec succès, comme dans les cas de test précédents. Ensuite, nous récupérons le premier produit de la liste et simulons un appui dessus avec fireEvent.press. Enfin, nous nous attendons à ce que la fonction navigate de l’objet navigation ait été appelée avec les paramètres RouteName et productId attendus.
2.1.5 Cas de test : il doit ajouter et retirer correctement un produit lors de l’appui sur l’icône panier du produit
Le cas de test ci-dessous teste le scénario où l’utilisateur ajoute un produit au panier puis le retire, en appuyant sur l’icône panier de la carte du produit dans l’écran de liste des produits.
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);
});
});
Pour tester le fonctionnement de l’icône panier dans le header, nous devons afficher tout le ProductStack en plus du ProductListScreen. En effet, nous devons accéder au header de l’écran de liste des produits pour récupérer l’icône panier grâce à son test ID. Cela nous oblige à afficher tout le ProductStack, avec le NavigationContainer.
Une fois les produits récupérés avec succès, le test utilise fireEvent.press pour simuler un appui sur l’icône panier du premier produit, ce qui ajoute le produit au panier. Nous vérifions ensuite que l’icône panier affiche la bonne quantité, et que le produit a été ajouté au tableau productsInBasket du store des produits avec la bonne quantité et le bon objet produit.
Après cela, nous simulons un nouvel appui sur l’icône panier pour retirer le produit du panier, et nous vérifions que l’icône panier n’affiche plus de quantité et que le tableau productsInBasket du store des produits est vide.
En résumé, ce cas de test vérifie l’ajout et le retrait d’un produit du panier, ainsi que l’ajustement des quantités, en appuyant sur l’icône panier de la carte du produit dans l’écran de liste des produits, et confirme que le store des produits gère correctement les produits et leurs quantités dans le panier.
2.1.6 Le flux de test complet de l’écran de liste des produits
Voici le flux de test complet de l’écran de liste des produits :
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);
});
});
Pour conclure
Pour conclure, cet article a exploré des stratégies de test efficaces pour les applications React Native qui utilisent React-Query et Zustand, deux bibliothèques très populaires aujourd’hui dans les applications React/React Native. En prenant l’exemple d’une simple application de boutique, avec des exemples complets et détaillés, nous avons couvert le processus de test et la façon de garantir la qualité du code grâce aux tests. N’hésitez pas à consulter le code source complet via le lien ci-dessous. Bonne journée !
Lien vers le code source complet
Publié sur
Cet article est également publié sur :