React Native ist dank seines schnellen Entwicklungszyklus und seiner plattformübergreifenden Kompatibilität eine beliebte Wahl für mobile Anwendungen geworden. Um das Beste aus der Entwicklung mit React Native herauszuholen, greifen Entwickler oft zu Libraries von Drittanbietern wie React-Query und Zustand, um Data Fetching und State-Management zu erledigen. React-Query bietet einen flexiblen und effizienten Weg, deine Daten abzurufen, zu cachen und zu verwalten, während Zustand das State-Management mit seinem minimalistischen Ansatz einfach und gleichzeitig mächtig macht.
In diesem Artikel schauen wir uns an, wie man React-Native-Anwendungen, die diese beiden Libraries nutzen, effektiv testet. Als Beispiel verwenden wir eine einfache Shop-App und zeigen ausführliche, detaillierte Beispiele, die dir helfen, den Testprozess zu verstehen. Am Ende dieses Artikels wirst du gut verstehen, wie du React-Query und Zustand in deinen React-Native-Apps einsetzt und testest.
1. Die Umgebung einrichten
Wir initialisieren unsere Shop-App mit React Native in der Version 0.71.2 und nutzen React-Query (Tanstack Query) in der Version 3.39.3 sowie Zustand in der Version 4.3.2 für Data Fetching und State-Management. Den vollständigen Quellcode der fertigen App stelle ich auf GitHub bereit. Wenn du also direkt einsteigen und sie in Aktion sehen willst, kannst du den Link am Ende des Artikels öffnen. So kannst du die Beispiele mitverfolgen und den kompletten Code der App sehen.
1.1 Die Store-API einrichten
Wir verwenden https://fakestoreapi.com als API, um effektive Testtechniken in React Native zu zeigen. Unsere Shop-App ruft eine Reihe von Produkten von dieser API ab und bietet eine Detailansicht für jedes Produkt. FakeStoreProduct hat zwar noch weitere REST-APIs, die wir nutzen könnten, aber das würde die Komplexität erhöhen und vom eigentlichen Ziel dieses Artikels ablenken.
Um in unserer App mit der API zu kommunizieren, erstellen wir eine axios-Instanz.
1.2 Die axios-Instanz einrichten
import axios from "axios";
export const BASE_URL = "https://fakestoreapi.com";
export const api = axios.create({
baseURL: BASE_URL,
});
Als Nächstes richten wir react-query für unsere API ein.
1.3 Die Key Factory für das Query-Caching erstellen
Was ist eine Key Factory?
Auch wenn unsere einfache App nicht unbedingt Caching braucht, nutzen wir trotzdem die leistungsstarken Caching-Features von React-Query. Deshalb erstellen wir eine einfache Key Factory, die unten gezeigt wird.
export const productKeyFactory = {
products: ["all-products"],
productById: (id: number) => [...productKeyFactory.products, id],
} as const;
1.4 Produkte mit react-query abrufen
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,
});
};
Oben haben wir den Hook useGetAllProducts zum Abrufen der Produkte erstellt und dabei den Query Key aus dem vorherigen Abschnitt verwendet.
1.5 Produktdetails mit react-query abrufen
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,
});
};
Fast dasselbe wie der vorherige Hook, nur dass diesmal der Hook useGetProductById verwendet wird, um die Details eines Produkts anhand seiner ID abzurufen.
1.6 Der Produkttyp
Überspringen wir nicht, wie das Produktobjekt eigentlich aussieht.
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 Jetzt kommt Zustand: Produkte im Warenkorb verwalten
Die App bekommt grundlegende Features, mit denen Nutzer Produkte zu ihrem Warenkorb hinzufügen oder daraus entfernen und die Menge einzelner Produkte anpassen können. Außerdem können Nutzer den gesamten Warenkorb zurücksetzen. Diese Funktionen werden mit Zustand verwaltet. Unten schauen wir uns die Implementierung an.
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
);
Der erste Teil des Codes definiert drei Funktionen, updateProductQuantity, increaseProductQuantityInBasket und decreaseProductQuantityInBasket. Das sind Hilfsmethoden, um die Menge eines Produkts im Warenkorb zu aktualisieren. Die Funktion updateProductQuantity nimmt als Eingabe ein Array von Objekten, das productsInBasket entspricht, eine Produkt-ID und einen Update-Typ (erhöhen oder verringern) und gibt ein neues Array productsInBasket mit der aktualisierten Menge für das jeweilige Produkt zurück.
Das Interface ProductStore definiert das Schema für den Produkt-Store. Es enthält zwei Eigenschaften:
-
productsInBasket ist ein Array von ProductInBasket-Objekten, das die Produkte im Warenkorb repräsentiert.
-
actions ist ein Objekt mit Funktionen zur Verwaltung der Produkte im Warenkorb, darunter ein Produkt hinzufügen, ein Produkt entfernen, seine Menge erhöhen/verringern und den Warenkorb zurücksetzen.
Der Hook useProductStore wird mit der Funktion create von Zustand erstellt. Er gibt den Produkt-Store mit seinem State und seinen Actions zurück.
Die übrigen Hooks, useProductActions, useProductsInBasket, useProductsInBasketCount und useProductInBasketQuantityById, sind Selektoren, die vom Hook useProductStore abgeleitet sind. Sie ermöglichen den Zugriff auf bestimmte Teile des Produkt-Stores, etwa auf die Actions oder die Anzahl der favorisierten Produkte.
Erwähnenswert ist außerdem, dass wir in useProductsInBasket shallow aus zustand verwendet haben. Der Grund: Das Array von Objekten, das useProductsInBasket zurückgibt, würde ein Rerender auslösen, weil es sich nicht um primitive Typen* handelt. Deshalb sagen wir zustand einfach, dass das Objekt flach verglichen werden soll, indem wir die Funktion für Shallow Equality übergeben.
1.8 Die nötigen Pakete zum Testen installieren
Jetzt kommen wir zu dem Teil, der uns mehr interessiert: dem Testen. Wir verwenden die folgenden Pakete:
Der Kürze halber und um den Artikel nicht unnötig in die Länge zu ziehen, lassen wir einige Schritte zur Konfiguration der Testumgebung weg, etwa jest.config.js und ts-jest.
Wie wir die Testumgebung am Ende eingerichtet haben, kannst du dir gern über den Link zum vollständigen Quellcode am Ende des Artikels ansehen.
1.9 API-Daten mit MSW mocken
Um unsere App mit react-query effektiv zu testen, müssen wir unsere API mocken. Dafür nutzen wir 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);
Im Code oben importieren wir die nötigen Module und richten die MSW-Handler ein. Wir erstellen zwei gemockte Endpunkte, einen zum Abrufen aller Produkte und einen zum Abrufen eines Produkts anhand seiner ID, die beide eine erfolgreiche Response zurückgeben. Für gründliche Tests erstellen wir außerdem fehlschlagende Handler für diese beiden Endpunkte, um Fehlerszenarien zu simulieren und zu testen.
Um das Mocking-Setup oben abzuschließen, müssen wir das Objekt mswServer in unserer jest.setup.js verwenden. Wir wollen mswServer einfach vor allen Testfällen initialisieren, die Handler nach jedem Testfall zurücksetzen und ihn am Ende herunterfahren.
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");
Jetzt haben wir unsere API gemockt, damit wir sie in den Tests verwenden können. Fertig sind wir aber noch nicht. Wir müssen auch das Testen von zustand einrichten, und zwar mit der Dokumentation, die sie bereitstellen. So können wir den State zwischen Tests zurücksetzen, wenn wir zustand in unseren Testfällen verwenden.
1.10 Zustand für Tests konfigurieren
// 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()));
});
Entscheidend ist hier, die Datei oben je nach Testumgebung im richtigen Verzeichnis abzulegen. Da wir jest verwenden, sollten wir diese Datei unter mocks/zustand.js ablegen, wie in der Dokumentation beschrieben.
Vielleicht fühlst du dich vom Einrichten der (Test-)Umgebung schon überwältigt, aber ich musste diese Punkte trotzdem behandeln, denn sie sind das Gerüst unserer Umgebung.
Springen wir also direkt in den Abschnitt, in dem wir unseren Screen zur Anzeige der Produkte bauen.
2. Überblick über den Produktlisten-Screen
Wie gesagt, wir bekommen einen Screen zur Anzeige der Produkte. Hier ist der vollständige Code des Produktlisten-Screens:
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",
},
});
Dieser Screen ist für Folgendes zuständig:
-
Produkte mit dem eigenen React-Query-Hook useGetAllProducts anzeigen, den wir im Abschnitt 1.4 Produkte mit react-query abrufen erstellt haben.
-
Nutzern ermöglichen, Produkte mit dem eigenen Zustand-Hook useProductActions zum Warenkorb hinzuzufügen oder daraus zu entfernen, den wir ebenfalls im Abschnitt 1.7 Jetzt kommt Zustand: Produkte im Warenkorb verwalten behandelt haben.
-
Produkte per Pull-to-Refresh erneut abrufen.
-
Den Mengentext am Warenkorb-Icon rechts im Header aktualisieren.
Hier eine Demonstration des Produktlisten-Screens:

2.1 Den Produktlisten-Screen testen
In diesem Abschnitt testen wir den Produktlisten-Screen. Die ersten Testfälle sind folgende:
-
Anfangs sollte die Ladeanzeige zu sehen sein, auch wenn wir die Daten mocken. Das Boolean-Flag isLoading in react-query ist trotzdem für kurze Zeit true. Nachdem die Daten abgerufen wurden, ist isLoading false, und der Loader wird nicht mehr angezeigt.
-
Die Produktliste sollte nach dem Abrufen der Daten korrekt angezeigt werden. Um diesen Fall zu prüfen, nutzen wir das Prop testID der Komponente ProductListCard.
-
Wenn die Query zum Abrufen aller Produkte fehlschlägt, sollte der Screen eine Fehlermeldung anzeigen. Dafür nutzen wir den Helper setupGetAllProductsFailedHandler, den wir in 1.9 API-Daten mit MSW mocken erstellt haben.
2.1.1 Testfall: Anfangs sollte die Ladeanzeige zu sehen sein
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();
});
});
Ganz oben in der Datei importieren wir die nötigen Module, um unsere Tests auszuführen. Dann erstellen wir eine Variable namens component, in der unser Produktlisten-Screen gespeichert wird, damit wir sie in allen Testfällen wiederverwenden können. Da es sich um einen Screen handelt und wir im Abschnitt 2. Überblick über den Produktlisten-Screen sowie in Zeile 22 Screen-Props deklariert haben, müssen wir außerdem die erforderlichen Screen-Props navigation und route übergeben. Warum wir oben das Objekt navigation destrukturiert haben, sehen wir in den kommenden Testfällen.
Ein kurzer Überblick über die Begriffe, die wir kennen müssen, um die Testfälle zu verstehen:
-
render: Rendert das übergebene React-Element vollständig in die Tiefe und gibt Helfer zurück, mit denen sich die Struktur der ausgegebenen Komponenten abfragen lässt.
-
screen: Enthält den Wert des letzten render-Aufrufs, um einfacher auf Queries und andere Funktionen zuzugreifen, die render zurückgibt.
-
renderHook: Rendert eine Testkomponente, die bei jedem Rendern den übergebenen Callback aufruft, einschließlich aller Hooks, die er aufruft.
Da das Hauptziel dieses Artikels ist, eine Anleitung zum Testen zu geben, und nicht, die Testing-Libraries und ihre Funktionen vorzustellen, gehen wir nicht tief ins Detail. Im Laufe des Artikels gibt es ohnehin genug Beispiele, die ihre Verwendung zeigen.
Der Testfall oben prüft, ob anfangs eine Loader-Komponente auf dem Screen angezeigt wird. Die Funktion render rendert die Komponente ProductListScreen, verpackt in die Funktion createReactQueryWrapper. Das ist eine einfache Utility-Funktion, mit der ein QueryClientProvider erstellt wird. Die Funktion screen.queryByTestId() prüft, ob der Loader auf dem Screen angezeigt wird.
Die Funktion renderHook wird verwendet, um den Hook useGetAllProducts zu testen, den die Komponente ProductListScreen zum Abrufen der Produktdaten nutzt. Der Funktion renderHook wird die Option wrapper übergeben, damit der Hook useGetAllProducts in die Funktion createReactQueryWrapper verpackt wird. Die Variable result enthält den Wert, den der Hook useGetAllProducts zurückgibt. Die Funktion waitFor wartet derweil, bis die Eigenschaft isSuccess des Objekts result true ist, die Produktdaten also erfolgreich abgerufen wurden.
Der zweite Teil prüft, ob die Loader-Komponente nicht mehr angezeigt wird, nachdem die Produktdaten erfolgreich abgerufen wurden.
Wir haben queryByTestId statt getByTestId verwendet, weil wir wissen, dass die Loader-Komponente nach dem Abrufen der Daten nicht mehr sichtbar ist. getByTestId würde deshalb einen Fehler werfen.
Mit getByTestId könnten wir zum Beispiel auf diesen Fehler stoßen:

2.1.2 Testfall: Die Daten der Produktliste sollten korrekt angezeigt werden
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();
}
});
});
Dieser Testcode prüft, ob der Produktlisten-Screen die abgerufenen Produktdaten korrekt anzeigt.
Auch diesmal warten wir, bis die Daten erfolgreich abgerufen wurden. Dann stellen wir sicher, dass die Daten der Produktliste korrekt angezeigt werden, indem wir über die abgerufenen Daten iterieren und erwarten, dass für jedes Produkt eine Produktlisten-Karte mit der testID product-list-card-${id} existiert. Die Eigenschaft id wird dynamisch anhand der Produkt-ID erzeugt. Schlägt der Test fehl, zeigen die Einträge der Produktliste die Produktdaten nicht korrekt an.
Beachte, wie wir unten die Funktion renderItem verwendet haben, um die Listeneinträge zu rendern. Wir nehmen product.id und kombinieren es mit dem String product-list-card, um eine dynamische testID für die Komponente ProductListCard zu erzeugen. So können wir alle Produkte zusammen mit ihrem jeweiligen Prop testID testen.
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 Testfall: Ein Fehlertext sollte erscheinen, wenn die Query für alle Produkte fehlschlägt
In diesem Testfall testen wir das Szenario, in dem der API-Aufruf zum Abrufen aller Produkte fehlschlägt.
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();
});
});
Um einen API-Fehler zu simulieren, verwenden wir die Funktion setupGetAllProductsFailedHandler aus dem Mock Service Worker (msw), die wir im Abschnitt 1.9 API-Daten mit MSW mocken in Zeile 38 implementiert haben. Dann rendern wir die Komponente ProductListScreen mit der Funktion render und rufen mit der Funktion renderHook den Hook useGetAllProducts auf, der die Daten abruft.
Mit der Funktion waitFor aus @testing-library/react-hooks warten wir, bis die Eigenschaft isError des Objekts result.current true wird. So ist sichergestellt, dass der Hook fertig ausgeführt wurde und der API-Aufruf fehlgeschlagen ist. Schließlich prüfen wir mit der Funktion getByText aus @testing-library/react-native, ob die Fehlermeldung "An error occurred" auf dem Screen angezeigt wird. Das kannst du im Quellcode des Produktlisten-Screens noch einmal nachprüfen.
2.1.4 Testfall: Beim Tippen auf das erste Produkt sollte eine Navigationsaktion aufgerufen werden
Wir testen das folgende Snippet, das direkt aus unserem Produktlisten-Screen stammt. Dieser Code verarbeitet das Tippen des Nutzers auf eine beliebige Produktlisten-Karte in der 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)}
/>
);
};
Schauen wir uns an, wie wir das testen können:
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 diesem Testcode prüfen wir, ob die Navigationsaktion aufgerufen wird, wenn auf ein Produkt getippt wird. Zuerst rendern wir die Komponente ProductListScreen und warten wie in den vorherigen Testfällen, bis die Daten erfolgreich abgerufen wurden. Danach holen wir den ersten Produkteintrag aus der Liste und simulieren mit fireEvent.press einen Tap darauf. Schließlich erwarten wir, dass die Funktion navigate des Objekts navigation mit dem erwarteten RouteName und den Parametern für productId aufgerufen wurde.
2.1.5 Testfall: Beim Tippen auf das Warenkorb-Icon eines Produkts sollte es korrekt hinzugefügt/entfernt werden
Der folgende Testfall testet das Szenario, in dem der Nutzer ein Produkt zum Warenkorb hinzufügt und wieder entfernt, indem er auf dem Produktlisten-Screen auf das Warenkorb-Icon der Produktkarte tippt.
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);
});
});
Um die Funktion des Warenkorb-Icons im Header zu testen, müssen wir zusätzlich zum ProductListScreen den gesamten ProductStack rendern. Denn wir müssen auf den Header des Produktlisten-Screens zugreifen, um das Warenkorb-Icon über seine Test-ID zu finden. Dafür muss der gesamte ProductStack zusammen mit dem NavigationContainer gerendert sein.
Nachdem die Produkte erfolgreich abgerufen wurden, simuliert der Test mit fireEvent.press einen Tap auf das Warenkorb-Icon des ersten Produkts, wodurch das Produkt zum Warenkorb hinzugefügt wird. Dann prüfen wir, ob das Warenkorb-Icon die richtige Menge anzeigt und ob das Produkt mit der richtigen Menge und dem richtigen Produktobjekt im Array productsInBasket des Produkt-Stores gelandet ist.
Danach simulieren wir einen erneuten Tap auf das Warenkorb-Icon, um das Produkt wieder aus dem Warenkorb zu entfernen, und prüfen, ob das Warenkorb-Icon keine Menge mehr anzeigt und das Array productsInBasket im Produkt-Store leer ist.
Zusammengefasst testet dieser Testfall das Hinzufügen und Entfernen eines Produkts im Warenkorb sowie das Anpassen der Mengen durch Tippen auf das Warenkorb-Icon der Produktkarte auf dem Produktlisten-Screen und bestätigt, dass der Produkt-Store die Produkte und ihre Mengen im Warenkorb korrekt verwaltet.
2.1.6 Der vollständige Testablauf für den Produktlisten-Screen
Der vollständige Testablauf für den Produktlisten-Screen sieht so aus:
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);
});
});
Zusammenfassung
Abschließend hat dieser Artikel effektive Teststrategien für React-Native-Anwendungen gezeigt, die die Libraries React-Query und Zustand nutzen, die heute in React- und React-Native-Anwendungen ziemlich beliebt sind. Anhand einer einfachen Shop-App und ausführlicher, detaillierter Beispiele haben wir den Testprozess behandelt und gezeigt, wie man die Codequalität durch Tests sicherstellt. Den vollständigen Quellcode findest du über den Link unten. Einen schönen Tag noch!
Link zum vollständigen Quellcode
Veröffentlicht auf
Dieser Artikel ist auch erschienen auf: