# Testa React Native med React Query och Zustand

By Tarik Pinarci (https://tarikpinarci.com). Published 2022-04-30. Canonical: https://tarikpinarci.com/sv/blog/testing-react-native-with-react-query-and-zustand

React Native har blivit ett populärt val för att bygga mobilappar tack vare den snabba utvecklingscykeln och stödet för flera plattformar. För att få ut det mesta av React Native-utveckling vänder sig utvecklare ofta till tredjepartsbibliotek som React-Query och Zustand för datahämtning och state management. React-Query ger ett flexibelt och effektivt sätt att hämta, cacha och hantera din data, medan Zustand gör state management enkelt och kraftfullt med sitt minimalistiska upplägg.

I den här artikeln utforskar vi hur man effektivt testar React Native-appar som använder de här två biblioteken. Vi använder en enkel butiksapp som exempel och visar utförliga och detaljerade exempel som hjälper dig att förstå testprocessen. När du har läst klart har du god förståelse för hur du använder och testar React-Query och Zustand i dina React Native-appar

### 1. Sätta upp miljön

Vi använder React Native version **_0.71.2_** för att initiera vår butiksapp, och React-Query (Tanstack query) version **_3.39.3_** och Zustand version **_4.3.2_** för datahämtning och state management. Jag delar hela källkoden för den färdiga appen på GitHub, så om du vill hoppa in och se den i praktiken kan du göra det via [länken som delas i slutet av artikeln](#8fa3). Då kan du följa med i exemplen och se hela koden för appen.

### 1.1 Sätta upp butikens API

Vi använder [https://fakestoreapi.com](https://fakestoreapi.com/) som API för att visa effektiva testtekniker i React Native. Vår butiksapp hämtar ett antal produkter från det här API:et och visar en detaljvy för varje produkt. FakeStoreProduct har visserligen andra REST-API:er som vi skulle kunna använda, men det skulle öka komplexiteten och ta fokus från artikelns huvudsyfte.

För att kommunicera med vårt API i hela appen skapar vi en axios-instans.

### 1.2 Konfigurera axios-instansen

```tsx
import axios from "axios";

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

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

Nästa steg är att sätta upp react-query för vårt API.

### 1.3 Skapa en key-factory för att hantera cachning av queries

Vad är en key-factory?

[**_I grunden hanterar TanStack Query cachningen av queries åt dig baserat på query keys. Query keys måste vara en Array på toppnivå och kan vara så enkla som en Array med en enda sträng, eller så komplexa som en array med många strängar och nästlade objekt. Så länge query keyn är serialiserbar och unik för queryns data kan du använda den!_**](https://tanstack.com/query/latest/docs/react/guides/query-keys)

Även om vår enkla app inte nödvändigtvis kräver cachning kommer vi ändå att använda React-Querys kraftfulla funktioner för cachning. Därför skapar vi en enkel key-factory, som visas nedan.

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

### 1.4 Hämta produkter med react-query

```tsx
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,
  });
};
```

Ovan har vi skapat hooken useGetAllProducts för att hämta produkterna, och vi använder query keyn som vi skapade i föregående avsnitt.

### 1.5 Hämta produktdetaljer med react-query

```tsx
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,
  });
};
```

Nästan samma som föregående hook, förutom att hooken useGetProductById den här gången används för att hämta produktens detaljer utifrån dess id.

### 1.6 Produkttypen

Låt oss inte hoppa över att få en bild av hur produktobjektet ser ut.

```tsx
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 Här kommer zustand: hantera produkterna i varukorgen

Appen har grundläggande funktioner som låter användare lägga till eller ta bort produkter i varukorgen och justera antalet av enskilda produkter. Dessutom kan användarna tömma hela varukorgen. De här funktionerna hanteras med Zustand. Nedan går vi igenom implementationen.

```tsx
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
  );
```

Den första delen av koden definierar tre funktioner, updateProductQuantity, increaseProductQuantityInBasket och decreaseProductQuantityInBasket, som är hjälpmetoder för att uppdatera antalet av en produkt i varukorgen. Funktionen updateProductQuantity tar en array av objekt som motsvarar productsInBasket, ett produkt-ID och en typ av uppdatering (öka eller minska) som indata, och returnerar en ny array productsInBasket med det uppdaterade antalet för den angivna produkten.

Interfacet ProductStore definierar schemat för produktstoren. Det innehåller två egenskaper:

1. productsInBasket är en array av ProductInBasket-objekt som representerar produkterna i varukorgen.

1. actions är ett objekt med funktioner för att hantera produkterna i varukorgen, bland annat för att lägga till en produkt, ta bort en produkt, öka eller minska antalet och tömma varukorgen.

Hooken useProductStore skapas med funktionen create från Zustand. Den returnerar produktstoren med dess state och actions.

De återstående hookarna, useProductActions, useProductsInBasket, useProductsInBasketCount och useProductInBasketQuantityById, är selektorer som härleds från hooken useProductStore. De ger åtkomst till specifika delar av produktstoren, till exempel actions eller antalet favoritmarkerade produkter.

Värt att nämna är också att vi använde shallow från zustand i useProductsInBasket. Det beror på att arrayen av objekt som returneras från useProductsInBasket orsakar en omrendering eftersom objekten inte är [**_primitiva typer_**](https://developer.mozilla.org/en-US/docs/Glossary/Primitive)\*, så [vi säger helt enkelt till zustand att vi vill att objektet jämförs ytligt genom att skicka in funktionen för ytlig likhet.](https://github.com/pmndrs/zustand#selecting-multiple-state-slices)

### 1.8 Installera paketen som behövs för testning

Nu kan vi gå vidare till den del vi bryr oss mer om: testning. Vi använder paketen nedan:

- [jest (29.4.1)](https://jestjs.io/)

- [ts-jest (29.0.5)](https://github.com/kulshekhar/ts-jest)

- [@testing-library/react-hooks (8.0.1)](https://react-hooks-testing-library.com/)

- [@testing-library/react-native (11.5.1)](https://callstack.github.io/react-native-testing-library/)

- [Mock service worker, även kallat MSW\*(1.0.0)](https://mswjs.io/)\*

För att hålla artikeln kort hoppar vi över en del av konfigurationen av testmiljön, som jest.config.js och ts-jest .

Ta gärna en titt på hur vi till slut satte upp testmiljön via länken till den fullständiga källkoden i slutet av artikeln.

### 1.9 Mocka API-data med MSW

För att effektivt kunna testa vår app med react-query behöver vi mocka vårt API. För det använder vi mock service worker (MSW).

```tsx
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);
```

I koden ovan importerar vi de moduler som behövs och sätter upp MSW-hanterarna. Vi skapar två mockade endpoints, en för att hämta alla produkter och en för att hämta en produkt via dess id, och båda returnerar ett lyckat svar. För att testa ordentligt skapar vi också hanterare som misslyckas för de två endpointsen, så att vi kan simulera och testa felscenarier.

För att slutföra mockningen ovan behöver vi använda objektet mswServer i vår jest.setup.js . Vi vill helt enkelt initiera mswServer före alla testfall, återställa hanterarna efter varje testfall och till sist stänga ner den.

```tsx
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");
```

Nu har vi mockat vårt API så att vi kan använda det i testerna. Men vi är inte riktigt klara än. Vi behöver också sätta upp testning för zustand [enligt dokumentationen som de tillhandahåller.](https://docs.pmnd.rs/zustand/guides/testing) Det gör att vi kan [återställa state mellan tester](https://docs.pmnd.rs/zustand/guides/testing) när vi använder zustand i våra testfall.

### 1.10 Konfigurera zustand för testning

```tsx
// 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()));
});
```

Det viktiga här är att lägga filen ovan i rätt katalog beroende på testmiljön. Eftersom vi använder jest ska filen ligga i **mocks**/zustand.js [enligt beskrivningen i dokumentationen](https://docs.pmnd.rs/zustand/guides/testing).

Du kanske redan känner dig överväldigad av att sätta upp (test)miljön, men jag behövde ändå gå igenom den, eftersom den är skelettet i vår miljö.

Med det sagt hoppar vi direkt in i avsnittet där vi skapar skärmen som visar produkterna.

### 2. Översikt över produktlistskärmen

Som vi nämnde tidigare kommer vi att ha en skärm som visar produkter. Låt oss se hela koden för produktlistskärmen nedan:

```tsx
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",
  },
});
```

Den här skärmen ansvarar för följande:

- Visa produkter med den egna react query-hooken useGetAllProducts , som vi skapade i avsnittet **_1.4 Hämta produkter med react-query_**.

- Låta användare lägga till eller ta bort produkter i varukorgen med den egna zustand-hooken useProductActions, som vi också gick igenom i avsnittet **_1.7 Här kommer zustand: hantera produkterna i varukorgen_**.

- Hämta produkterna på nytt med pull-to-refresh.

- Uppdatera antalstexten som visas vid varukorgsikonen till höger i headern.

Här är en demonstration av produktlistskärmen:

![](https://cdn-images-1.medium.com/max/2000/1*7wGmDzti0z-d0oPFkKkhCw.gif)

### 2.1 Testa produktlistskärmen

I det här avsnittet testar vi produktlistskärmen. De första testfallen vi kör är följande:

- Till en början ska laddningsindikatorn visas, även om vi mockar datan. Den booleska flaggan isLoading i react-query är ändå satt till true en kort stund. När datan har hämtats är isLoading false, och laddningsindikatorn visas inte.

- Produktlistan ska visas korrekt när datan har hämtats. Propen testID på komponenten ProductListCard används för att verifiera det här fallet.

- Om queryn för att hämta alla produkter misslyckas ska skärmen visa ett felmeddelande. Vi använder hjälpfunktionen setupGetAllProductsFailedHandler som skapades i **_1.9 Mocka API-data med MSW_**

### 2.1.1 Testfall: Den ska visa laddningsindikatorn till en början

```tsx
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();
  });
});
```

Högst upp i filen har vi importerat de moduler som behövs för att köra testerna. Sedan skapade vi en variabel som heter component för att lagra vår produktlistskärm, så att vi kan återanvända variabeln i alla testfall. Eftersom det är en skärm, och vi deklarerade skärmens props i avsnittet **_2. Översikt över produktlistskärmen_** och på **_rad 22_**, behöver vi dessutom skicka in de skärmprops som krävs, navigation och route. Vi återkommer i kommande testfall till varför vi destrukturerade navigation-objektet ovan.

**En kort genomgång av begrepp vi behöver känna till för att förstå testfallen:**

- [render](https://callstack.github.io/react-native-testing-library/docs/api#render): Renderar det angivna React-elementet på djupet och returnerar hjälpfunktioner för att göra queries mot strukturen av de renderade komponenterna.

- [screen](https://callstack.github.io/react-native-testing-library/docs/api#screen): Håller värdet från det senaste render-anropet för enklare åtkomst till queries och andra funktioner som returneras av [render](https://callstack.github.io/react-native-testing-library/docs/api#render).

- [renderHook](https://react-hooks-testing-library.com/reference/api#renderhook) : Renderar en testkomponent som anropar den angivna callbacken, inklusive alla hooks den anropar, varje gång den renderas.

  > Eftersom huvudsyftet med den här artikeln är att visa hur man testar, snarare än att introducera testbiblioteken och deras funktioner, går vi inte in på dem i detalj. Vi kommer ändå att ha tillräckligt med exempel genom artikeln för att se hur de används.

Testfallet ovan kontrollerar om en laddningskomponent för skärmen visas till en början. Funktionen render renderar komponenten ProductListScreen inslagen i funktionen createReactQueryWrapper, som är en enkel hjälpfunktion för att skapa en [QueryClientProvider](https://tanstack.com/query/v4/docs/react/reference/QueryClientProvider) . Funktionen screen.queryByTestId() kontrollerar om laddningskomponenten visas på skärmen.

Funktionen renderHook används för att testa hooken useGetAllProducts, som används i komponenten ProductListScreen för att hämta produktdatan. Alternativet wrapper skickas till funktionen renderHook för att slå in hooken useGetAllProducts i funktionen createReactQueryWrapper. Variabeln result innehåller värdet som returneras av hooken useGetAllProducts. Samtidigt väntar funktionen waitFor tills egenskapen isSuccess på objektet result är true, vilket betyder att produktdatan har hämtats.

Den andra delen kontrollerar att laddningskomponenten inte längre visas efter att produktdatan har hämtats.

> Anledningen till att vi använde queryByTestId i stället för getByTestId är att vi vet att laddningskomponenten **inte kommer att synas** efter att datan har hämtats, så getByTestId skulle kasta ett fel.

Felet vi skulle få om vi använde getByTestId skulle kunna se ut så här:

![](https://cdn-images-1.medium.com/max/2236/1*l3eXZ10vsIAEedjFSUBQ4w.png)

### 2.1.2 Testfall: Den ska visa produktlistans data korrekt

```tsx
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();
    }
  });
});
```

Den här testkoden testar om produktlistskärmen visar den hämtade produktdatan korrekt.

Även den här gången väntar vi på att datan ska hämtas, och sedan säkerställer vi att produktlistans data visas korrekt genom att loopa igenom den hämtade datan och förvänta oss att ett produktkort med testID product-list-card-${id} finns för varje produkt i datan. Egenskapen id genereras dynamiskt utifrån produktens ID. Om testet misslyckas betyder det att elementen i produktlistan inte visar produktdatan korrekt.

Lägg märke till hur vi använde funktionen renderItem för att rendera listelementen nedan. Vi loopar igenom product.id och kombinerar det med strängen product-list-card för att generera ett dynamiskt testID för komponenten ProductListCard. På så sätt kan vi testa alla produkter tillsammans med deras respektive testID-prop.

```tsx
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: Den ska visa en feltext om queryn för att hämta alla produkter misslyckas

I det här testfallet testar vi scenariot där API-anropet för att hämta alla produkter misslyckas.

```tsx
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();
  });
});
```

För att simulera att API:et fallerar använder vi funktionen setupGetAllProductsFailedHandler från mock service worker (msw), som vi implementerade i avsnittet **_1.9 Mocka API-data med MSW_** på rad 38. Sedan renderar vi komponenten ProductListScreen med funktionen render och anropar hooken useGetAllProducts, som hämtar datan, med funktionen renderHook.

Vi använder funktionen waitFor från @testing-library/react-hooks för att vänta på att egenskapen isError på objektet result.current blir true. Det säkerställer att hooken har körts klart och att API-anropet har misslyckats. Till sist kontrollerar vi att felmeddelandet "An error occurred", som du kan dubbelkolla i källkoden för produktlistskärmen, visas på skärmen genom att se om texten finns med funktionen getByText från @testing-library/react-native.

### 2.1.4 Testfall: Den ska anropa en navigationshandling vid tryck på den första produkten

Vi testar följande kodsnutt, som faktiskt är hämtad från vår produktlistskärm. Koden ansvarar för att hantera när användaren trycker på något av produktkorten i listan.

```tsx
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)}
    />
  );
};
```

Så här kan vi gå tillväga för att testa den:

```tsx
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,
    });
  });
});
```

I den här testkoden testar vi om navigationshandlingen anropas när man trycker på en produkt. Först renderar vi komponenten ProductListScreen och väntar på att datan ska hämtas, precis som i tidigare testfall. Sedan hämtar vi den första produkten i listan och simulerar ett tryck på den med fireEvent.press. Till sist förväntar vi oss att funktionen navigate på navigation-objektet har anropats med förväntade parametrar för RouteName och productId.

### 2.1.5 Testfall: Den ska lägga till och ta bort en produkt korrekt vid tryck på produktens varukorgsikon

Testfallet nedan testar scenariot där användaren lägger till och tar bort en produkt i varukorgen genom att trycka på varukorgsikonen på produktkortet på skärmen Product List.

```tsx
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);
  });
});
```

För att testa funktionen hos varukorgsikonen i headern behöver vi rendera hela ProductStack utöver ProductListScreen. Det beror på att vi behöver komma åt headern på skärmen Product List för att hämta varukorgsikonen via dess test-ID. Det kräver att hela ProductStack renderas tillsammans med NavigationContainer .

När produkterna har hämtats använder testet fireEvent.press för att simulera ett tryck på varukorgsikonen på den första produkten, vilket lägger produkten i varukorgen. Sedan kontrollerar vi att varukorgsikonen visar rätt antal och att produkten har lagts till i arrayen productsInBasket i produktstoren med rätt antal och rätt produktobjekt.

Därefter simulerar vi ett nytt tryck på varukorgsikonen för att ta bort produkten från varukorgen, och kontrollerar att varukorgsikonen inte längre visar något antal och att arrayen productsInBasket i produktstoren är tom.

Sammanfattningsvis testar det här testfallet att lägga till och ta bort en produkt i varukorgen och att justera antalet genom att trycka på varukorgsikonen på produktkortet på skärmen Product List, och bekräftar att produktstoren hanterar produkterna och deras antal i varukorgen korrekt.

### 2.1.6 Hela testflödet för produktlistskärmen

Hela testflödet för produktlistskärmen ser ut så här:

```tsx
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);
  });
});
```

---

### Sammanfattning

Avslutningsvis har den här artikeln utforskat effektiva teststrategier för React Native-appar som använder biblioteken React-Query och Zustand, som är ganska populära i React- och React Native-appar nu för tiden. Med en enkel butiksapp som exempel och utförliga, detaljerade exempel har vi gått igenom testprocessen och hur man säkerställer kodkvalitet genom att skriva tester. Ta gärna en titt på hela källkoden via länken nedan. Ha en bra dag!

[**Länk till hela källkoden**](https://github.com/tarikfp/react-native-testing)

### Publicerad på

**Den här artikeln är också publicerad på:**

- [Medium](https://levelup.gitconnected.com/testing-react-native-with-react-query-and-zustand-d957c2a40b73)

