Hvordan tester du state logic?

Question

Accepted Answer

At teste state logic bygger tillid til, at dine state transitions og updates er korrekte. Strategien afhænger af *hvordan* logikken er struktureret — rene funktioner (reducers) er nemmest at teste, så velarkitektureret state er også veltest-able state.

## Test rene reducers direkte (den nemmeste, højeste værdi sag)

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

Fordi reducers er rene funktioner, kalder du dem blot med input og påstår output — ingen rendering, ingen mocking, hurtigt og deterministisk. Dette er *hvorfor* pure-reducer mønsteret værdsættes så højt.

## Test selectors

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

## Test custom hooks / store logic

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

`renderHook` + `act` lader dig teste hook/store state logic isoleret.

## Test komponenter efter adfærd, ikke internals

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

Test hvad brugeren ser/gør (adfærd), ikke implementeringsdetaljer — så refactors knuser ikke tests.

## Test async state (mock netværket)

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

Brug MSW eller mocks til at teste loading/success/error transitions deterministisk.

## Hvad man skal prioritere

```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
```

## Hvorfor det betyder noget

State bugs er blandt de mest påvirkende, så testing af state logic er høj værdi.

Vigtigst er **velstruktureret state naturligt testbar**: rene reducers og selectors er trivielle at unit teste (ingen mocks, deterministisk), hvilket er et stærkt argument for denne arkitektur.

At vide hvordan man tester reducers/selectors direkte, hooks med `renderHook`, komponenter efter bruger-synlig adfærd og async flows med mockede netværk — mens man undgår skrøbelige implementation-detail tests — giver pålidelig coverage af den logik, der er mest tilbøjelig til at forårsage subtile bugs.