Testing Reagere Kroker Med Enzymet, og Reagerer Testing Bibliotek

0
7

Når du begynner å gjøre bruk av Reagere kroker i dine programmer, vil du ønsker å være sikker på koden du skriver, det er intet mindre solid. Det er ingenting som frakt buggy kode. En måte å være sikker på koden din er fri for feil er å skrive tester. Og testing Reagere kroker er ikke mye forskjellig fra hvordan Reagerer programmene er testet generelt.

I denne opplæringen vil vi se på hvordan du gjør det ved å gjøre bruk av en to-do-programmet bygget med kroker. Vi kommer tilbake med å skrive tester ved hjelp av Ezyme og Reagere Testing Bibliotek, som begge er i stand til å gjøre nettopp det. Hvis du er ny til Enzymet, vi har faktisk skrevet om det en liten stund tilbake, som viser hvordan det kan brukes med Spøk i Reagerer programmer. Det er ikke en dårlig idé å sjekke at når vi grave i testing Reagere kroker.

Her er hva vi ønsker å teste

En ganske standard å gjøre komponent ser noe som dette:

import Reagere, { useState, useRef } fra “reagere”;
const Todo = () => {
const [todos, setTodos] = useState([
{ id: 1, artikkel: “Fix bugs” },
{ id: 2, artikkel: “Ta ut søpla” }
]);
const todoRef = useRef();
const removeTodo = id => {
setTodos(todos.filteret(todo => gjøremål.id !== id));
};
const addTodo = data => {
la id = todos.lengde + 1;
setTodos([
…todos,
{
id,
element: data
}
]);
};
const handleNewTodo = e => {
e.preventDefault();
const item = todoRef.gjeldende;
addTodo(element.verdi);
elementet.verdi = “”;
};
retur (
<div className=”beholder”>
<div className=”row”>
<div className=”col-md-6″>
<h2>Legg Todo</h2>
</div>
</div>
<form>
<div className=”row”>
<div className=”col-md-6″>
<input
type=”text”
autofokus
ref={todoRef}
plassholder=”skriv Inn en oppgave”
className=”form-kontroll”
data-testid=”input”
/>
</div>
</div>
<div className=”row”>
<div className=”col-md-6″>
<- knappen
type=”submit”
onClick={handleNewTodo}
className=”btn btn-primær”
>
Legg Til Oppgave
</button>
</div>
</div>
</form>
<div className=”rad todo-liste”>
<div className=”col-md-6″>
<h3>Viser</h3>
{!todos.lengden ? (
<div className=”no-oppgave”>Ingen oppgave!</div>
) : (
<ul data-testid=”todos”>
{todos.kart(todo => {
retur (
<li key={todo.id}>
<div>
<span>{todo.elementet}</span>
<- knappen
className=”btn btn-fare”
data-testid=”slett”-knappen
onClick={() => removeTodo(todo.id -)}
>
X
</button>
</div>
</li>
);
})}
</ul>
)}
</div>
</div>
</div>
);
};
eksport standard Todo;

Testing med Enzymet

Vi trenger å installere pakker før vi kan begynne å teste. På tide å fyre opp terminalen!

npm installere –spare-dev enzym enzym-adapter-16

Inne i src-katalogen, kan du opprette en fil som heter setupTests.js. Dette er hva vi kan bruke til å konfigurere Enzym-adapter.

import Enzym fra “enzym”;
import-Adapteren fra “enzym-adapter, for å reagere-16”;
Enzymet.konfigurere({ adapter: ny Adapter() });

Nå kan vi begynne å skrive testene våre! Vi ønsker å teste fire ting:

  1. At komponenten gjør
  2. Som den første gjøremål blir vist når det gjør
  3. At vi kan skape en ny to-do og komme tilbake tre andre
  4. At vi kan slette en av de første til-dos, og har bare ett å gjøre venstre

I src-katalogen, kan du opprette en mappe som heter __tester__ og opprette filen hvor du vil skrive Todo komponent tester i det. La oss kalle denne filen Todo.test.js.

Med det gjort, vi kan importere pakker trenger vi og lage en beskrive blokk der vi skal fylle i våre tester.

import Reagere fra “reagere”;
import { grunne, mount } fra “enzym”;
import-Todo fra “../Todo”;

beskrive(“Todo”, () => {
// Tester vil gå her ved hjelp av `det` blokker
});
Test 1: komponenten gjør

For dette, vil vi gjøre bruk av grunne furer. Grunne gjengivelse tillater oss å undersøke om de render metoden for komponenten blir kalt — det er hva vi ønsker å bekrefte her fordi det er de bevis vi trenger at komponenten gjør.

det(“gjør”, () => {
grunne(<Todo />);
});
Test 2: Første gjøremål blir vist

Her er der vi vil gjøre bruk av mount metode, som gjør det mulig for oss å gå dypere enn hva grunne gir oss. På den måten kan vi kontrollere lengden på gjøremålene.

det(“viser første til-dos”, () => {
const wrapper = mount(<Todo />);
forventer(wrapper.finn(“li”)).toHaveLength(2);
});
Test 3: Vi kan lage en ny til-gjøre og få tilbake tre andre

La oss tenke på prosessen involvert i å lage en ny å gjøre:

  1. Brukeren skriver inn en verdi i feltet.
  2. Brukeren klikker send-knappen.
  3. Vi får en sum av tre gjøremål, hvor den tredje er nylig opprettet.

det(“legger til et nytt element”, () => {
const wrapper = mount(<Todo />);
wrapper.finn(“input”).eksempel().value = “Fikse sviktende test”;
forventer(wrapper.finn(“input”).eksempel().verdien).toEqual(“Fikse sviktende test”);
wrapper.finn(‘[type=”submit”]’).simulere(“klikk”);
forventer(wrapper.finn(“li”)).toHaveLength(3);
forventer(
wrapper
.finn(“li div span”)
.siste()
.tekst()
).toEqual(“Fikse sviktende test”);
});

Vi monterer komponent da vi gjøre bruk av finn() og forekomst() metoder for å angi verdien for feltet. Vi hevde at verdien av input-feltet er satt til å “Fikse sviktende test” før du går videre for å simulere klikk på arrangementet, som skal legge til det nye elementet til å-gjøre-liste.

Vi endelig hevde at vi har tre elementer på listen og som det tredje elementet er lik den vi opprettet.

Test 4: Vi kan slette en av de første til-dos, og har bare ett å gjøre venstre
det(“fjerner et element”, () => {
const wrapper = mount(<Todo />);
wrapper
.finn(“li-knappen”)
.første()
.simulere(“klikk”);
forventer(wrapper.finn(“li”)).toHaveLength(1);
forventer(wrapper.finn(“li span”).kart(item => elementet.tekst())).toEqual([
“Ta ut søpla”
]);
});

I dette scenariet, er vi tilbake til-gjøre med en simulert klikk på hendelsen på det første elementet. Det er forventet at dette vil ringe removeTodo () – metoden, som bør slette elementet som ble klikket på. Da vi sjekker tallene av elementer vi har, og verdien av den som blir returnert.

Kildekoden for disse fire testene er her på GitHub for deg å sjekke ut.

Testing Med reagere-testing-bibliotek

Vi vil skrive tre tester for dette:

  1. At den første til å-gjøre-gjør
  2. At vi kan legge til et nytt gjøremål
  3. At vi kan slette et gjøremål

La oss starte ved å installere pakker vi trenger:

npm installere –spare-dev @testing-library/spøk-dom @testing-library/reagere

Neste, vi kan importere pakker og filer:

import Reagere fra “reagere”;
import { gjengi, fireEvent } fra “@testing-library/reagere”;
import-Todo fra “../Todo”;
import “@testing-library/spøk-dom/extend-forventer”;

test(“Todo”, () => {
// Tester gå her
}
Test 1: Den første til å-gjøre-gjør

Vi vil skrive testene våre i en test blokk. Den første testen vil se ut som dette:

det(“viser første til-dos”, () => {
const { getByTestId } = render(<Todo />);
const todos = getByTestId(“todos”);
forventer(todos.barn.lengden).toBe(2);
});

Hva skjer her? Vi gjør bruk av getTestId for å gå tilbake noden av element der data-testid samsvarer med den som ble sendt til metoden. Det er <ul> – element i dette tilfellet. Så, vi sjekker at det har en total av to barn (hvert barn blir en <li> element i den sorterte listen). Dette vil passere som den første å gjøre er lik to.

Test 2: Vi kan legge til et nytt gjøremål

Vi gjør også bruk av getTestById her for å gå tilbake til den noden som samsvarer med det argumentet vi passerer.

det(“legger til en ny to-do”, () => {
const { getByTestId, getByText } = render(<Todo />);
const input = getByTestId(“input”);
const todos = getByTestId(“todos”);
input.value = “Fikse sviktende tester”;
fireEvent.klikk(getByText(“Legg til Oppgave”));
forventer(todos.barn.lengden).toBe(3);
});

Vi bruker getByTestId for å gå tilbake tekstfeltet og ul element som vi gjorde før. For å simulere klikk på en hendelse som legger til et nytt gjøremål-element, vi bruker fireEvent.klikk på() og pasninger i getByText () – metoden, som gir den noden med tekst som samsvarer med det argumentet vi passerte. Fra det vi kan se lengden på til-dos ved å kontrollere lengden på barn utvalg.

Test 3: Vi kan slette et gjøremål

Dette vil se ut litt som det vi gjorde litt tidligere:

det(“slette et gjøremål”, () => {
const { getAllByTestId, getByTestId } = render(<Todo />);
const todos = getByTestId(“todos”);
const deleteButton = getAllByTestId(“slett”-knappen);
const første = deleteButton[0];
fireEvent.klikk på(første);
forventer(todos.barn.lengden).toBe(1);
});

Vi gjør bruk av getAllByTestId å returnere noder på slett-knappen. Siden vi kun ønsker å slette ett element, kan vi skyte en klikk på arrangementet på første element i samlingen, som bør slette den første til å gjøre. Dette skal da gjøre lengden av todos barn lik én.

Disse testene er også tilgjengelig på GitHub.

Linting

Det er to lo regler å følge når du arbeider med kroker:

Regel 1: Ring-kroker på øverste nivå

…i motsetning til inne conditionals, sløyfer eller nestede funksjoner.

// Ikke gjøre dette!
hvis (Matematikk.random() > 0.5) {
const [ugyldig, updateInvalid] = useState(false);
}

Dette går mot den første regelen. I henhold til den offisielle dokumentasjonen, Reagerer avhenger av i hvilken rekkefølge kroker er kalt til å knytte staten og den tilsvarende useState samtale. Denne koden bryter den rekkefølgen som kroken vil bare bli kalt dersom vilkårene er oppfylt.

Dette gjelder også useEffect og andre kroker. Sjekk ut dokumentasjon for mer informasjon.

Regel 2: Samtale kroker fra Reagere funksjonelle komponenter

Krokene er ment å bli brukt i Reagerer funksjonelle komponenter — ikke Reagere i sin klasse komponent eller en JavaScript-funksjon.

Vi har i utgangspunktet dekkes hva du ikke skal gjøre når det kommer til linting. Vi kan unngå disse feiltrinn med en npm-pakke som er spesielt håndhever disse reglene.

npm installere eslint-plugin-reagere-kroker –spare-dev

Her er hva vi legger til pakken er konfigurasjonsfilen til å gjøre det gjøre sin ting:

{
“plugins”: [
// …
“reagere-kroker”
],
“regler”: {
// …
“reagere-kroker/regler-for-kroker”: “feil”,
“reagere-kroker/utfyllende-deps”: “advare”
}
}

Hvis du gjør bruk av Lag Reagere App, bør du vite at pakken støtter lo-plugin ut av boksen som i v3.0.0.

Gå ut og skrive solid Reagere koden!

Reagerer kroker er like utsatt for feil som noe annet i programmet, og du skal ønsker å sikre at du bruker dem godt. Som vi nettopp så, det er et par måter vi kan gå om det. Enten du bruker Enzym eller Du kan enten gjøre bruk av enzym eller Reagere Testing Biblioteket for å skrive tester er helt opp til deg. Uansett, kan du prøve å gjøre bruk av linting som du går, og ingen tvil, vil du være glad du gjorde.