Conas a dhéanann tú tástáil ar loighic stáit?

Question

Accepted Answer

Tháirgir tástáil ar loighic stáit go bhfuil do thairiscintí agus do nuashonruithe stáit ceart. Braitheann an straitéis ar *conas* a bhíonn an loighic struchtúrtha — is iad na feidhmeanna íona (reducers) na cinn is éasca a bhaint as an tástáil, agus dá bhrí sin is stáit bhreá a bheas a bhaint as tástáil a bheas stáit atá sainithe go maith.

## Tástáil ar reducers íona go díreach (an cás is simplí agus is ard-luach)

```js
// reducers are pure: (state, action) => newState → trivial to test, no mocks
describe("todosReducer", () => {
  it("adds a todo", () => {
    const initial = [];
    const next = todosReducer(initial, { type: "todos/added", payload: { id: 1, text: "A" } });
    expect(next).toEqual([{ id: 1, text: "A" }]);
    expect(initial).toEqual([]); // ✅ verify the original wasn't mutated (immutability)
  });
});
```

Toisc gur feidhmeanna íona iad na reducers, ní dhéanann tú ach iad a ghlaoch le ionchur agus an t-aschur a dhearbhú — gan rindreáil, gan magaireáil, tapa agus cinnte. Is é seo an fáth *go bhfuil* an patrún reducer íona in ardmhéin.

## Tástáil ar roghnóirí

```js
it("selects the cart total", () => {
  const state = { cart: { items: [{ price: 10 }, { price: 5 }] } };
  expect(selectCartTotal(state)).toBe(15);
});
```

## Tástáil ar dhúchasach hooks / loighic stór

```jsx
import { renderHook, act } from "@testing-library/react";

it("increments", () => {
  const { result } = renderHook(() => useCounter());
  act(() => result.current.increment()); // act wraps state updates
  expect(result.current.count).toBe(1);
});
```

Ligeann `renderHook` + `act` duit loighic stáit an hook/stór a bhaint as go hachomhair.

## Tástáil ar chomhpháirteanna trí iompar, ní trí bharúil inmheánach

```jsx
import { render, screen, fireEvent } from "@testing-library/react";

it("shows the count after clicking", () => {
  render(<Counter />);
  fireEvent.click(screen.getByRole("button"));
  expect(screen.getByText("1")).toBeInTheDocument(); // assert the rendered RESULT
});
```

Tástáil ar a bhfeiceann/a dhéanann an úsáideoir (iompar), ní ar shonraí an chur i bhfeidhm — chun go nach dtógfaidh athmhúnlaithe na tástálacha.

## Tástáil ar stáit neamhshioncronaithe (mag an líonra)

```js
// mock fetch/API (e.g. MSW), then assert loading → success/error transitions
it("handles fetch error → error state", async () => { ... });
```

Úsáid MSW nó magaireáilí chun aistrithe load/rath/earráid a bhaint as go cinnte.

## Ar a bhfuil an cumas a dhíolaim

```text
Reducers/selectors/pure logic → unit test thoroughly (cheap, high value)
Component behavior           → integration test key user flows
Async flows                  → test transitions with mocked APIs
Don't test framework internals or trivial setters
```

## Cén fáth a bhfuil sé tábhachtach

Tá fabhtanna stáit i measc na gceann is tionchar a imirt, agus dá bhrí sin tá luach ard ag tástáil ar loighic stáit.

Go príobháideach, **stáit atá struchtúrtha go maith atá in-inmheánaigthe go dúchasta**: is beag an iarracht atá agat ar shreafadh íona agus ar roghnóirí a bhaint as thástálacha aonad (gan magaireáilí, cinnte), agus is argóint dhocht í seo ar thaca an ailtireachta sin.

A bheith ar an eolas conas reducers/roghnóirí a bhaint as go díreach, hooks le `renderHook`, comhpháirteanna trí iompar atá feicthe ag an úsáideoir, agus sreafhanna neamhshioncronaithe le líonraí magairite — agus tástálacha brittil bhunaithe ar shonraí an chur i bhfeidhm a sheachaint — tugann sé clúdach iontaofa ar an loighic is dóichí go gcruthaíonn sí fabhtanna caolchúiseach.