React Native is een populaire keuze geworden voor het bouwen van mobiele applicaties, dankzij de snelle ontwikkelcyclus en de cross-platform compatibiliteit. Om het maximale uit React Native-ontwikkeling te halen, grijpen developers vaak naar third-party libraries zoals React-Query en Zustand voor het ophalen van data en state management. React-Query biedt een flexibele en efficiënte manier om je data op te halen, te cachen en te beheren, terwijl Zustand state management eenvoudig en krachtig maakt met zijn minimalistische aanpak.
In dit artikel bekijken we hoe je React Native-applicaties die deze twee libraries gebruiken effectief kunt testen. We gebruiken een eenvoudige winkel-app als voorbeeld en geven uitgebreide, gedetailleerde voorbeelden om je te helpen het testproces te begrijpen. Aan het eind van dit artikel heb je een goed beeld van hoe je React-Query en Zustand gebruikt en test in je React Native-apps
1. De omgeving opzetten
We gebruiken React Native versie 0.71.2 om onze winkel-app te initialiseren, en React-Query (Tanstack query) versie 3.39.3 en Zustand versie 4.3.2 voor het ophalen van data en state management. Ik deel de volledige broncode van de complete app op GitHub, dus als je meteen wilt beginnen en alles in actie wilt zien, kan dat via de link die aan het eind van het artikel staat. Zo kun je de voorbeelden volgen en de complete code van de app bekijken.
1.1 De store-API opzetten
We gebruiken https://fakestoreapi.com als API om effectieve testtechnieken in React Native te laten zien. Onze winkel-app haalt een set producten op uit deze API en toont een detailweergave van elk product. FakeStoreProduct heeft nog andere REST-API's die we zouden kunnen gebruiken, maar dat zou de complexiteit verhogen en afleiden van het hoofddoel van dit artikel.
Om in de hele app met onze API te communiceren, maken we een axios-instantie aan.
1.2 De axios-instantie opzetten
import axios from "axios";
export const BASE_URL = "https://fakestoreapi.com";
export const api = axios.create({
baseURL: BASE_URL,
});
De volgende stap is het opzetten van react-query voor onze API.
1.3 De key-factory maken voor het beheren van query-caching
Wat is een key-factory?
Hoewel onze app zo eenvoudig is dat caching niet per se nodig is, maken we toch gebruik van de krachtige caching van React-Query. Daarom maken we een eenvoudige key-factory, die je hieronder ziet.
export const productKeyFactory = {
products: ["all-products"],
productById: (id: number) => [...productKeyFactory.products, id],
} as const;
1.4 Producten ophalen met 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,
});
};
Hierboven hebben we de hook useGetAllProducts gemaakt om de producten op te halen, en daarbij gebruiken we de query key die we in het vorige onderdeel hebben gemaakt.
1.5 Productdetails ophalen met 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,
});
};
Bijna hetzelfde als de vorige hook, alleen wordt de hook useGetProductById deze keer gebruikt om de details van een product op te halen via het id.
1.6 Het producttype
Laten we niet overslaan hoe het productobject er eigenlijk uitziet.
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 Hier komt zustand: producten in het winkelmandje beheren
De app krijgt basisfuncties waarmee gebruikers producten aan hun winkelmandje kunnen toevoegen of eruit kunnen verwijderen, en de hoeveelheid van afzonderlijke producten kunnen aanpassen. Daarnaast kunnen gebruikers het hele winkelmandje leegmaken. Deze functionaliteit beheren we met Zustand. Hieronder bekijken we de implementatie.
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
);
Het eerste deel van de code definieert drie functies, updateProductQuantity, increaseProductQuantityInBasket en decreaseProductQuantityInBasket. Dit zijn hulpmethodes voor het bijwerken van de hoeveelheid van een product in het winkelmandje. De functie updateProductQuantity krijgt als input een array met objecten die overeenkomt met productsInBasket, een product-ID en een type update (increase of decrease), en geeft een nieuwe array productsInBasket terug met de bijgewerkte hoeveelheid voor het betreffende product.
De interface ProductStore definieert het schema van de product store. Die heeft twee properties:
-
productsInBasket is een array van ProductInBasket-objecten die de producten in het winkelmandje voorstellen.
-
actions is een object met functies om de producten in het winkelmandje te beheren, zoals een product toevoegen, een product verwijderen, de hoeveelheid verhogen of verlagen, en het winkelmandje leegmaken.
De hook useProductStore wordt gemaakt met de functie create van Zustand. Die geeft de product store terug met zijn state en actions.
De overige hooks, useProductActions, useProductsInBasket, useProductsInBasketCount en useProductInBasketQuantityById, zijn selectors die zijn afgeleid van de hook useProductStore. Ze geven toegang tot specifieke delen van de product store, zoals de actions of het aantal favoriete producten.
Verder is het goed om te vermelden dat we shallow van zustand hebben gebruikt in useProductsInBasket. Dat komt doordat de array met objecten die useProductsInBasket teruggeeft een rerender zou veroorzaken, omdat het geen primitieve types* zijn. Daarom vertellen we zustand simpelweg dat we het object oppervlakkig willen vergelijken door de functie voor shallow equality mee te geven.
1.8 De benodigde packages voor het testen installeren
Nu kunnen we verder met het deel waar het ons eigenlijk om gaat: testen. We gebruiken de volgende packages:
Om het artikel kort te houden, laten we een paar stappen voor het configureren van de testomgeving weg, zoals jest.config.js en ts-jest .
Via de link naar de complete broncode aan het eind van het artikel kun je gerust bekijken hoe we de testomgeving uiteindelijk hebben opgezet.
1.9 API-data mocken met MSW
Om onze app met react-query effectief te kunnen testen, moeten we onze API mocken. Daarvoor gebruiken we 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);
In de code hierboven importeren we de benodigde modules en zetten we de MSW-handlers op. We maken twee mock-endpoints, één voor het ophalen van alle producten en één voor het ophalen van een product via het id, die allebei een succesvolle response teruggeven. Om grondig te kunnen testen, maken we voor deze twee endpoints ook handlers die falen, zodat we foutscenario's kunnen simuleren en testen.
Om de mock-setup hierboven af te ronden, moeten we het object mswServer gebruiken in onze jest.setup.js . We willen mswServer simpelweg initialiseren vóór alle testcases, na elke testcase de handlers resetten, en hem aan het eind afsluiten.
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");
We hebben onze API nu gemockt, zodat we hem in de tests kunnen gebruiken. Maar we zijn nog niet klaar. We moeten ook het testen van zustand opzetten, met behulp van de documentatie die ze aanbieden. Daarmee kunnen we de state tussen tests resetten wanneer we zustand in onze testcases gebruiken.
1.10 Zustand configureren voor het testen
// 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()));
});
Het belangrijkste hier is dat je het bestand hierboven in de juiste map zet, afhankelijk van je testomgeving. Omdat we jest gebruiken, moeten we dit bestand in mocks/zustand.js plaatsen, zoals beschreven in de documentatie.
Misschien voel je je al overweldigd door al dat opzetten van de (test)omgeving, maar ik moest het toch behandelen, omdat het het skelet van onze omgeving vormt.
Dat gezegd hebbende, laten we meteen doorgaan naar het onderdeel waarin we ons scherm voor het tonen van de producten maken.
2. Overzicht van het productlijstscherm
Zoals eerder gezegd krijgen we een scherm om producten te tonen. Hieronder zie je de volledige code van het productlijstscherm:
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",
},
});
Dit scherm is verantwoordelijk voor het volgende:
-
Producten tonen met de eigen react query-hook useGetAllProducts , die we hebben gemaakt in het onderdeel 1.4 Producten ophalen met react-query.
-
Gebruikers producten laten toevoegen aan of verwijderen uit hun winkelmandje met de eigen zustand-hook useProductActions, die we ook al hebben behandeld in het onderdeel 1.7 Hier komt zustand: producten in het winkelmandje beheren.
-
Producten opnieuw ophalen met pull-to-refresh.
-
De hoeveelheid bijwerken die wordt getoond bij het winkelmandje-icoon rechts in de header.
Hieronder zie je een demonstratie van het productlijstscherm:

2.1 Het productlijstscherm testen
In dit onderdeel gaan we het productlijstscherm testen. Dit zijn de eerste testcases die we uitvoeren:
-
In het begin moet de laadindicator worden getoond, ook al mocken we de data. De boolean-flag isLoading in react-query staat dan nog steeds een korte tijd op true. Nadat de data is opgehaald, is isLoading false en wordt de loader niet meer getoond.
-
De productlijst moet correct worden getoond nadat de data is opgehaald. We gebruiken de prop testID van de component ProductListCard om dit te controleren.
-
Als de query om alle producten op te halen faalt, moet het scherm een foutmelding tonen. We gebruiken daarvoor de helper setupGetAllProductsFailedHandler die we hebben gemaakt in 1.9 API-data mocken met MSW
2.1.1 Testcase: het moet in het begin de laadindicator tonen
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();
});
});
Bovenaan het bestand importeren we de modules die nodig zijn om onze tests te draaien. Daarna maken we een variabele component aan om ons productlijstscherm in op te slaan, zodat we die variabele in al onze testcases kunnen hergebruiken. Omdat het een scherm is en we de screen props hebben gedeclareerd in onderdeel 2. Overzicht van het productlijstscherm, en in regel 22, moeten we ook de vereiste screen props meegeven: navigation en route. In de volgende testcases komen we erop terug waarom we het navigation-object hierboven hebben gedestructureerd.
Een kort overzicht van de terminologie die we moeten kennen om de testcases te begrijpen:
-
render: rendert het gegeven React-element volledig (deep render) en geeft helpers terug om de structuur van de gerenderde componenten te queryen.
-
screen: bewaart de waarde van de laatste aanroep van render, zodat je makkelijker bij de queries en andere functies kunt die render teruggeeft.
-
renderHook : rendert een testcomponent die bij elke render de meegegeven callback aanroept, inclusief alle hooks die daarin worden aangeroepen.
Omdat het hoofddoel van dit artikel is om uit te leggen hoe je test, en niet om testlibraries en hun functies te introduceren, gaan we daar niet diep op in. We zien in de rest van het artikel sowieso genoeg voorbeelden van hoe ze worden gebruikt.
De testcase hierboven controleert of er in het begin een screen loader-component op het scherm wordt getoond. De functie render rendert de component ProductListScreen binnen de functie createReactQueryWrapper, een eenvoudige utility-functie om een QueryClientProvider te maken. De functie screen.queryByTestId() controleert of de screen loader op het scherm wordt getoond.
De functie renderHook wordt gebruikt om de hook useGetAllProducts te testen, die in de component ProductListScreen wordt gebruikt om de productdata op te halen. De optie wrapper wordt aan de functie renderHook meegegeven om de hook useGetAllProducts in de functie createReactQueryWrapper te wrappen. De variabele result bevat de waarde die de hook useGetAllProducts teruggeeft. Ondertussen wacht de functie waitFor tot de property isSuccess van het object result true is, wat betekent dat de productdata succesvol is opgehaald.
Het tweede deel controleert of de screen loader-component niet meer wordt getoond nadat de productdata succesvol is opgehaald.
We gebruikten queryByTestId in plaats van getByTestId omdat we weten dat de screen loader-component niet zichtbaar zal zijn nadat de data is opgehaald. getByTestId zou dan een fout gooien.
Als we getByTestId zouden gebruiken, zouden we de volgende fout kunnen krijgen:

2.1.2 Testcase: het moet de data van de productlijst correct tonen
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();
}
});
});
Deze testcode test of het productlijstscherm de opgehaalde productdata correct toont.
Ook deze keer wachten we tot de data succesvol is opgehaald. Daarna controleren we of de data van de productlijst correct wordt getoond door over de opgehaalde data te loopen en te verwachten dat er voor elk product in de data een productlijstkaart met de testID product-list-card-${id} bestaat. De property id wordt dynamisch gegenereerd op basis van het product-ID. Als de test faalt, betekent dat dat de items in de productlijst de productdata niet correct tonen.
Kijk hieronder hoe we de functie renderItem gebruikten om de items in de lijst te renderen. We loopen over product.id en combineren dat met de string product-list-card om een dynamische testID voor de component ProductListCard te genereren. Op die manier kunnen we alle producten testen, elk met hun eigen testID-prop.
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 Testcase: het moet een fouttekst tonen als de query om alle producten op te halen faalt
In deze testcase testen we het scenario waarin de API-call om alle producten op te halen faalt.
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();
});
});
Om een falende API te simuleren, gebruiken we de functie setupGetAllProductsFailedHandler van mock server worker (msw), die we hebben geïmplementeerd in het onderdeel 1.9 API-data mocken met MSW op regel 38. Daarna renderen we de component ProductListScreen met de functie render en roepen we met de functie renderHook de hook useGetAllProducts aan, die de data ophaalt.
We gebruiken de functie waitFor uit @testing-library/react-hooks om te wachten tot de property isError van het object result.current true wordt. Zo weten we zeker dat de hook klaar is en dat de API-call is mislukt. Tot slot stellen we vast dat de foutmelding "An error occurred" (die je kunt nakijken in de broncode van het productlijstscherm) op het scherm wordt getoond, door met de functie getByText uit @testing-library/react-native te controleren of de tekst aanwezig is.
2.1.4 Testcase: het moet een navigatieactie aanroepen bij het indrukken van het eerste product
We gaan het volgende codefragment testen, dat eigenlijk uit ons productlijstscherm komt. Deze code handelt af wat er gebeurt als de gebruiker op een van de productlijstkaarten in de lijst drukt.
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)}
/>
);
};
Laten we hieronder bekijken hoe we het testen kunnen aanpakken:
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,
});
});
});
In dit testfragment testen we of de navigatieactie wordt aangeroepen wanneer er op een product wordt gedrukt. Eerst renderen we de component ProductListScreen en wachten we, net als in de vorige testcases, tot de data succesvol is opgehaald. Daarna halen we het eerste product uit de lijst op en simuleren we er een press-event op met fireEvent.press. Tot slot verwachten we dat de functie navigate van het object navigation is aangeroepen met de verwachte parameters RouteName en productId.
2.1.5 Testcase: het moet een product correct toevoegen en verwijderen bij het indrukken van het winkelmandje-icoon van het product
De testcase hieronder test het scenario waarin de gebruiker een product aan het winkelmandje toevoegt en weer verwijdert door op het winkelmandje-icoon op de productkaart in het productlijstscherm te drukken.
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);
});
});
Om de functionaliteit van het winkelmandje-icoon in de header te testen, moeten we naast ProductListScreen de hele ProductStack renderen. Dat komt doordat we toegang nodig hebben tot de header van het productlijstscherm om het winkelmandje-icoon via zijn test-ID op te halen. Daarvoor moet de hele ProductStack gerenderd zijn, samen met de NavigationContainer .
Nadat de producten succesvol zijn opgehaald, gebruikt de test fireEvent.press om een druk op het winkelmandje-icoon van het eerste product te simuleren, waardoor het product aan het winkelmandje wordt toegevoegd. Daarna controleren we of het winkelmandje-icoon de juiste hoeveelheid toont, en of het product met de juiste hoeveelheid en het juiste productobject is toegevoegd aan de array productsInBasket in de product store.
Vervolgens simuleren we nog een druk op het winkelmandje-icoon om het product weer uit het winkelmandje te halen, en controleren we of het winkelmandje-icoon de hoeveelheid niet meer toont en of de array productsInBasket in de product store leeg is.
Samengevat test deze testcase het toevoegen en verwijderen van een product in het winkelmandje en het aanpassen van de hoeveelheden door op het winkelmandje-icoon op de productkaart in het productlijstscherm te drukken. Hij bevestigt dat de product store de producten en hun hoeveelheden in het winkelmandje correct beheert.
2.1.6 De volledige testflow van het productlijstscherm
De volledige testflow van het productlijstscherm ziet er zo uit:
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);
});
});
Afronding
Kortom, in dit artikel hebben we effectieve teststrategieën bekeken voor React Native-applicaties die de libraries React-Query en Zustand gebruiken, die tegenwoordig behoorlijk populair zijn in React- en React Native-applicaties. Met een eenvoudige winkel-app als voorbeeld en uitgebreide, gedetailleerde voorbeelden hebben we het testproces behandeld en laten zien hoe je met tests de kwaliteit van je code bewaakt. Bekijk gerust de volledige broncode via de link hieronder. Fijne dag nog!
Link naar de volledige broncode
Gepubliceerd op
Dit artikel is ook gepubliceerd op: