రాష్ట్ర తర్కాన్ని ఎలా పరీక్షిస్తారు?

Question

Accepted Answer

రాష్ట్ర తర్కాన్ని పరీక్షించడం వల్ల మీ రాష్ట్ర పరివర్తనలు మరియు నవీకరణలు సరైనవని నమ్మకం పెరుగుతుంది. ఈ ఆస్తి *ఎలా* నిర్మించబడిందో దానిపై ఆధారపడి ఉంటుంది — чистые functions (reducers) పరీక్ష చేయడం చాలా సులభం, కాబట్టి బాగా నిర్మించిన రాష్ట్ర పరీక్ష కూడా బాగా నిర్మించిన రాష్ట్ర.

## शुद్ధ reducers సরাసరి పరీక్షించండి (సులభమైన, అత్యధిక-విలువ కేసు)

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

Reducers pure functions కాబట్టి, మీరు కేవలం వాటిని ఇన్‌పుట్‌తో కాల్ చేసి output ను నిశ్చితం చేస్తారు — rendering లేదు, mocking లేదు, వేగవంతమైనది మరియు నిర్ణయాత్మకమైనది. ఇది *ఎందుకు* pure-reducer నమూనా చాలా విలువైనదిగా ఉంది.

## Selectors పరీక్షించండి

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

## Custom hooks / store తర్కాన్ని పరీక్షించండి

```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` hook/store state తర్కాన్ని ఎక్కువగా పరీక్షించడానికి మీకు అనుమతిస్తుంది.

## Components ని internals ద్వారా కాక, behavior ద్వారా పరీక్షించండి

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

यूजర్ చూసిన/చేసిన (behavior) పరీక్షించండి, implementation details కాకుండా — కాబట్టి refactors పరీక్షలను విచ్ఛిన్నం చేయవు.

## Async state పరీక్షించండి (network ను mock చేయండి)

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

loading/success/error పరివర్తనలను నిర్ణయాత్మకంగా పరీక్షించడానికి MSW లేదా mocks ఉపయోగించండి.

## ఏమిటిని ప్రాధాన్యత ఇవ్వాలి

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

## ఇది ఎందుకు ముఖ్యమైనది

రాష్ట్ర bugs అత్యంత ప్రభావవంతమైనవి, కాబట్టి రాష్ట్ర తర్కాన్ని పరీక్షించడం అధిక-విలువ.

ముఖ్యంగా, **బాగా-నిర్మించిన రాష్ట్ర అంతర్నిహితంగా పరీక్ష చేయవచ్చు**: pure reducers మరియు selectors unit test చేయడం తక్షణమైనది (no mocks, నిర్ణయాత్మకమైనది), ఇది ఆ ఆర్కిటెక్చర కోసం బలమైన వాదన.

Reducers/selectors సరాసరి పరీక్షించడానికి, `renderHook` తో hooks, user-visible behavior ద్వారా components, మరియు mocked networks తో async flows — నిర్ణయాత్మక implementation-detail tests నుండి దూరంగా ఉండేటప్పుడు — సూక్ష్మమైన bugs కలిగిస్తున్న తర్కం యొక్క నమ్మదగిన కవరేజీ ఇస్తుంది.