Əsas məzmuna keç
FrontDepth, Ana səhifə

Testləşdirmə

Şəbəkəni və modulları mock etmək

Sonda öz mock-larını test etməyə başlamadan şəbəkəni və modulları necə saxtalaşdırmalı: seam seçimi, Mock Service Worker handler-ləri və loading və xəta vəziyyətləri üçün hər testə aid override-lar, fetch-i stub etməyin qiyməti, vi.mock-un yuxarı qaldırılması və qismən mock-lar, ES modullarının spy üçün məhdudiyyətləri və contract drift.

MiddleSeniorYenilənib: 16 noyabr 2026

Oxu səviyyəsi

Seçilmiş səviyyəyə qədər olan bölmələr göstərilir.

Bu mövzu Middle səviyyəsindən başlayır.

MiddleKonsepsiya

Seam seçimi: harada mock etməli

real bir şeyi əvəz edir, testin real kodu kəsdiyi yerə isə seam deyilir. Data yükləyən kodda üç tipik seam var:

Text
TaskList → useTasks() → api.getTasks() → fetch() → network → server

1. vi.mock("./api")         replaces api.getTasks()
2. vi.stubGlobal("fetch")   replaces fetch()
3. an MSW handler           replaces the server's answer

Seam nə qədər aşağıdadırsa, testdə sənin kodunun o qədər çox hissəsi işləyir. Öz api modulunu mock etsən (birinci seam), test URL-i quran, header-ləri təyin edən, body-ni serializasiya edən, response.ok-u yoxlayan, JSON-u parse edən və uğursuzluqları xətaya çevirən kodu heç vaxt işə salmır, halbuki səhvin ən çox ehtimal olunduğu yer məhz bu koddur. Üstəlik, wrapper-i refaktor edəndə (getTasks-ın adını dəyişəndə, arqumentlərini dəyişəndə) ekran əvvəlki kimi işləsə də test sınır.

Şəbəkə sərhədində mock etmək (üçüncü seam) yalnız həqiqətən tətbiqdən kənarda olanı əvəz edir: serveri. Komponent, hook, wrapper və real fetch hamısı işləyir; test yalnız serverin nə cavab verəcəyini həll edir. Eyni sorğuları və eyni UI-ı saxlayan refaktorinq testləri yaşıl saxlayır. Mock Service Worker (MSW) məhz bunun üçün yaradılıb, Vitest-in bələdçisi də sorğuları mock etmək üçün onu tövsiyə edir.

Sadə qayda: sənə aid olmayanı sənin koduna daxil olduğu nöqtədə mock et. HTTP üçün bu nöqtə sənin fetch ətrafındakı öz wrapper-in yox, kodundan çıxan sorğunun özüdür.

Asılılıq test etdiyin şəbəkə deyilsə, yenə düzgün alətdir:

  • testdə istəmədiyin yan təsirləri olan SDK: analitika, xəta hesabatları, ödəniş vidjeti;
  • ağır və ya jsdom-da işləməyən kitabxana: xəritə, WebGL qrafiki;
  • testin idarə etməli olduğu dəyər: feature flag client-i, ID generatoru.

Seam qırmızı testin nə demək olduğunu da müəyyən edir. Şəbəkə səviyyəsindəki test sınanda istifadəçinin görə biləcəyi davranış dəyişib. Öz modulunu mock edən test sınanda isə çox vaxt yalnız sənin iki faylın arasındakı çağırış dəyişib.

Qlobal fetch-i stub etmək (ikinci seam) ortada dayanır: wrapper-in işləyir, amma onun fetch-i necə çağırdığı dondurulur. Bunun qiyməti vi.stubGlobal bölməsində sadalanır.

MiddleFramework

Mock Service Worker: handler-lər və test serveri

MSW serverin cavablarını request handler-lər kimi təsvir edir: HTTP metodu, URL şablonu və cavab qaytaran resolver funksiyası.

TypeScript
// src/mocks/handlers.ts
import { http, HttpResponse } from "msw/http";

export const API = "https://api.example.com";

export const handlers = [
  http.get(`${API}/tasks`, () => {
    return HttpResponse.json([
      { id: "t1", title: "Write the release notes", done: false },
      { id: "t2", title: "Review the login page", done: true },
    ]);
  }),

  http.post(`${API}/tasks`, async ({ request }) => {
    const body = (await request.json()) as { title?: string };
    if (!body.title) {
      return HttpResponse.json({ message: "Title is required" }, { status: 400 });
    }
    return HttpResponse.json({ id: "t3", title: body.title, done: false }, { status: 201 });
  }),
];

Resolver real Request-i (request), path parametrlərini (params, /tasks/:id kimi şablon üçün) və cookies-i alır. HttpResponse.json(body, init) JSON body-li cavab qurur; init Response konstruktorunda olduğu kimi status və headers qəbul edir.

Vitest-də (Node) handler-ləri msw/node-dan gələn setupServer işə salır. Adına baxmayaraq, o, heç bir port açmır: test prosesinin daxilində çıxan sorğuları tutur, ona görə sənin kodunun real fetch çağırışı işləyir və handler-in cavabını alır.

TypeScript
// src/mocks/node.ts
import { setupServer } from "msw/node";
import { handlers } from "./handlers";

export const server = setupServer(...handlers);
TypeScript
// vitest.setup.ts (test.setupFiles-da göstərilib)
import "@testing-library/jest-dom/vitest";
import { afterAll, afterEach, beforeAll } from "vitest";
import { server } from "./src/mocks/node";

beforeAll(() => server.listen({ onUnhandledFrame: "error" }));
afterEach(() => server.resetHandlers());
afterAll(() => server.close());
  • listen() sorğuların tutulmasını başladır, close() isə dayandırır.
  • resetHandlers() testin server.use() ilə əlavə etdiyi handler-ləri silir və ilkin siyahını saxlayır.
  • onUnhandledFrame: "error" heç bir handler-ə uyğun gəlməyən sorğu üçün xəta yazır və sorğunu dayandırır. Default dəyər olan "warn" isə xəbərdarlıq yazıb sorğunu buraxır, ona görə URL-dəki bir hərf səhvi testi səssizcə real serverə göndərə bilər.

Bunlar MSW 3-ün adlarıdır. MSW 2 http və HttpResponse-u msw-dan export edirdi, seçimin adı isə onUnhandledRequest idi; MSW 3 onun adını dəyişdi, çünki o, indi WebSocket bağlantılarını da əhatə edir.

Brauzerdə eyni handler-lər msw/browser-dən gələn setupWorker vasitəsilə işləyir; o, Service Worker qeydiyyata alır (npx msw init <PUBLIC_DIR> --save onun skriptini public qovluğuna kopyalayır). Bu, hələ hazır olmayan API ilə lokal development, Storybook və brauzerdə işləyən test runner-lər üçün yararlıdır. Render-dən əvvəl worker.start()-ı await et, yoxsa ilk sorğular worker hazır olmamış gedə bilər.

MiddleNümunə

Loading, xəta və yavaş cavabların testi

TaskList ${API}/tasks-ı yükləyir və əvvəlcə role="status" ilə "Loading tasks..." göstərir, sonra siyahını, "No tasks yet." mətnini və ya alert-i. Default handler uğurlu ssenarini əhatə edir; qalan hər vəziyyət üçün bir server.use() çağırışı kifayətdir:

TSX
import { expect, test } from "vitest";
import { render, screen } from "@testing-library/react";
import { http, HttpResponse } from "msw/http";
import { delay } from "msw/utils/delay";
import { API } from "../mocks/handlers";
import { server } from "../mocks/node";
import { TaskList } from "./TaskList";

test("shows the tasks", async () => {
  render(<TaskList />);
  expect(await screen.findByText("Write the release notes")).toBeInTheDocument();
});

test("shows the empty state", async () => {
  server.use(http.get(`${API}/tasks`, () => HttpResponse.json([])));
  render(<TaskList />);
  expect(await screen.findByText("No tasks yet.")).toBeInTheDocument();
});

test("shows an error when the server fails", async () => {
  server.use(
    http.get(`${API}/tasks`, () => HttpResponse.json({ message: "Down" }, { status: 500 })),
  );
  render(<TaskList />);
  expect(await screen.findByRole("alert")).toHaveTextContent("Could not load tasks");
});

test("shows an error when the network fails", async () => {
  server.use(http.get(`${API}/tasks`, () => HttpResponse.error()));
  render(<TaskList />);
  expect(await screen.findByRole("alert")).toBeInTheDocument();
});

test("keeps the loading state while the server is silent", () => {
  server.use(
    http.get(`${API}/tasks`, async () => {
      await delay("infinite");
      return HttpResponse.json([]);
    }),
  );
  render(<TaskList />);
  expect(screen.getByRole("status")).toHaveTextContent("Loading tasks");
});
  • server.use() handler-ləri siyahının əvvəlinə əlavə edir, MSW isə cavab qaytaran ilk handler-i işlədir, ona görə override yalnız bu testdə qalib gəlir; afterEach-dəki resetHandlers() onu silir. { once: true } seçimi olan handler uyğun gələn bir sorğuya cavab verir, sonra nəzərə alınmır: "ilk sorğu uğursuz olur, təkrar cəhd alınır" ssenarisi üçün əlverişlidir.
  • 500 fetch-i reject etmir. Promise response.ok === false ilə resolve olur; yalnız şəbəkə xətası reject edir, HttpResponse.error() isə fetch-in TypeError ilə reject olmasına səbəb olur. Bunlar iki ayrı kod yoludur, ikisini də test et.
  • Arqumentsiz delay() brauzerdə realistik təsadüfi müddət gözləyir, Node-da isə testlər sürətli qalsın deyə bu gizli gecikmə ötürülür. delay(ms) dəqiq o qədər gözləyir, delay("infinite") isə heç vaxt cavab vermir.

İstifadəçinin gördüyünü yoxla, "sorğu göndərildi" faktını yox: MSW-nin sənədləri sorğu üzərində assertion-ları implementasiya detalı sayır və tövsiyə etmir. Body vacibdirsə, onu handler-də yoxla və POST /tasks handler-i kimi 400 qaytar; səhv body o zaman ekranda görünür.

MiddleTipik səhvlər

vi.stubGlobal ilə fetch-i stub etmək

MSW-nin tez alternativi fetch-in özünü əvəz etməkdir:

TypeScript
import { afterEach, expect, it, vi } from "vitest";
import { getTasks } from "./api";

afterEach(() => {
  vi.unstubAllGlobals();
});

it("loads the tasks", async () => {
  const fetchMock = vi.fn(async () =>
    Response.json([{ id: "t1", title: "Write the release notes", done: false }]),
  );
  vi.stubGlobal("fetch", fetchMock);

  const tasks = await getTasks();

  expect(tasks).toHaveLength(1);
  expect(fetchMock).toHaveBeenCalledWith("https://api.example.com/tasks");
});

vi.stubGlobal(name, value) qlobal dəyişəni dəyişir: globalThis.fetch-i, jsdom və ya happy-dom altında isə window.fetch-i də. vi.unstubAllGlobals() ilkin dəyərləri bərpa edir, unstubGlobals: true config seçimi isə onu hər testdən əvvəl çağırır. Adi mənimsətmə də (globalThis.fetch = ...) işləyir, amma onda unstubAllGlobals onu bərpa edə bilmir və saxta funksiya fayldakı sonrakı bütün testlərə keçir.

Test keçir, amma indi kodun nə etdiyini yox, fetch-i necə çağırdığını təsvir edir:

  • Çağırışın forması dondurulur. Kod ikinci arqument ötürən kimi (header-lər, AbortSignal), Request obyekti quran kimi və ya request kitabxanasına keçən kimi toHaveBeenCalledWith(url) sınır, halbuki istifadəçi üçün heç nə dəyişməyib.
  • Cavab nə yazmısansa, odur. Əllə qurulmuş { json: async () => data }-da ok, status və headers yoxdur, ona görə xətaların emalı real cavabla olduğu kimi heç vaxt işləmir. Yuxarıdakı kimi Response.json() heç olmasa real Response qurur.
  • Bir stub bütün sorğulara xidmət edir. /tasks və /me-ni yükləyən ekrana dəqiq çağırış sırası ilə mockResolvedValueOnce zənciri lazımdır. İki sorğunun yerini dəyiş, hər biri o birinin body-sini alacaq.
  • Başqa göndərmə yolları əhatə olunmur. XMLHttpRequest və ya navigator.sendBeacon işlədən kod stub-dan yan keçir.

MSW-də bu dörd problemin heç biri yoxdur: handler-lər sorğuya metod və URL üzrə uyğun gəlir, real cavablar qaytarır, hər endpoint-ə ayrıca cavab verir və sorğunun necə göndərildiyi onlar üçün fərq etmir.

vi.stubGlobal şəbəkə olmayan və test mühitində çatışmayan və ya testin idarə etməli olduğu qlobal dəyişənlər üçün düzgün alətdir: jsdom-un implementasiya etmədiyi IntersectionObserver, ResizeObserver və matchMedia, yaxud layout budağı üçün innerWidth. Onu unstubGlobals: true ilə birlikdə işlət ki, hər test real dəyərlərdən başlasın.

MiddleFramework

vi.mock: modulu əvəz etmək

vi.mock(path, factory?) modulu əvəz edir: həmin yolun hər import-u, həm testdə, həm də test olunan kodda, əvəzedicini alır. Burada completeTask PATCH /tasks/:id göndərir (ona MSW cavab verir) və analitika event-i bildirir; test isə onu real göndərməməlidir:

TypeScript
// tasks.test.ts
import { expect, it, vi } from "vitest";
import { trackEvent } from "./analytics";
import { completeTask } from "./tasks";

vi.mock("./analytics", () => ({
  trackEvent: vi.fn(),
}));

it("reports the completed task", async () => {
  await completeTask("t1");
  expect(trackEvent).toHaveBeenCalledWith("task_completed", { id: "t1" });
});

Burada çağırışı yoxlamaq normaldır: analitika event-i ekranda heç nə dəyişməyən birtərəfli yan təsirdir.

Hoisting. vi.mock faylın yuxarısına köçürülür və bütün import-lardan əvvəl işləyir, ona görə onların altında yazılması fərq etmir. Vitest faylın statik import-larını mock-un qeydiyyatını gözləyən dinamik import-lara çevirir. Nəticə: factory özündən kənarda, faylda elan olunmuş dəyişənləri işlədə bilməz, çünki o işləyəndə onlar hələ yoxdur. Ortaq dəyərləri özü də yuxarı qaldırılan vi.hoisted ilə yarat:

TypeScript
const { trackEvent } = vi.hoisted(() => ({ trackEvent: vi.fn() }));
vi.mock("./analytics", () => ({ trackEvent }));

Testin, describe-ın və ya funksiyanın içində çağırış yazıldığı yerdə işləməzdi; Vitest 5 belə halda xəta atır (əvvəlki versiyalar yalnız xəbərdarlıq edirdi). Yuxarı qaldırılmayan variant vi.doMock-dur.

Factory-nin qaytardığı obyekt modulun özüdür. Onun buraxdığı export-lar mövcud olmur, default export üçün isə default açarı lazımdır. Factory olmayanda Vitest __mocks__ qovluğundakı eyni adlı faylı işlədir; o da yoxdursa, real modulu avtomatik mock edir: funksiyalar undefined qaytaran mock-a çevrilir, massivlər boşalır, primitivlər olduğu kimi qalır, obyektlər dərin klonlanır.

Qismən mock-lar real modulu saxlayıb bir export-u əvəz edir:

TypeScript
vi.mock(import("./analytics"), async (importOriginal) => {
  const actual = await importOriginal();
  return { ...actual, trackEvent: vi.fn() };
});

Sətir yerinə import("./analytics") ötürmək importOriginal-a modulun tipini verir və factory-nin qaytardığı dəyəri həmin tiplə yoxlayır. vi.importActual(path) real modulu faylın istənilən yerində eyni cür yükləyir. Mock-u hər testdə tiplərlə qurmaq üçün onu bük: vi.mocked(trackEvent).mockReturnValue(...); vi.mocked yalnız tipi dəyişir və eyni funksiyanı qaytarır.

MiddleTipik səhvlər

Testlər arasında sıfırlama

Hər mock state-dir, bir testdən qalan state isə növbəti testi dəyişir. Simptomu: tək işləyəndə keçən, bütün faylla birlikdə isə sınan test, ya da əksinə; sıra dəyişən kimi belə testlər çevrilir. Nə sıza bilər və onu nə sıfırlayır:

  • MSW runtime handler-ləri. server.use() ilə qurulan override server.resetHandlers()-ə qədər qalır; afterEach-də o olmasa, bir testdə qurulan xəta vəziyyətini növbəti test alır.
  • Stub olunmuş qlobal dəyişənlər. vi.stubGlobal vi.unstubAllGlobals()-a qədər qalır; ya da unstubGlobals: true təyin et.
  • Mock implementasiyaları. Vitest 5 default olaraq hər testdən əvvəl çağırış tarixçəsini təmizləyir (clearMocks indi true-dur), amma mockReturnValue və ya mockImplementation ilə təyin olunmuş implementasiya qalır. mockReset: true hər testdən əvvəl implementasiyaları sıfırlayır; restoreMocks: true vi.spyOn ilə yaradılmış spy-ların orijinallarını geri qaytarır.
  • Modulların daxilindəki state. Modul hər test faylında bir dəfə icra olunur, ona görə API client-indəki keş, memoize olunmuş istifadəçi və ya ortaq data fetching client-i bir testdən digərinə keçir. Hər test üçün yeni instansiya yarat (singleton əvəzinə factory export et) və ya onu afterEach-də təmizlə.

Bir config bunların çoxunu bütün fayllar üçün işə salır:

TypeScript
// vitest.config.ts
import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    environment: "jsdom",
    globals: true,
    setupFiles: ["./vitest.setup.ts"],
    mockReset: true,
    restoreMocks: true,
    unstubGlobals: true,
  },
});

mockReset aktiv olanda hər mock-un davranışını faylın yuxarısında bir dəfə yox, testin özündə və ya beforeEach-də, ona ehtiyacı olan halın yanında təyin et. Belə oxumaq da asandır: test asılı olduğu cavabı özü göstərir.

Yaxşı yoxlama: bir testi .only ilə tək işə sal, sonra bütün faylı. Nəticələr fərqlənirsə, hansısa state ortaqdır. Onu tap və sıfırla; retry əlavə etmək onu sadəcə gizlədir.

SeniorKonsepsiya

ES modulları, canlı binding-lər və export-lara spy qoymaq

Import surət deyil, export edən modulun dəyişəninə canlı, yalnız oxunan baxışdır (bunu ES modulları mövzusu izah edir). Mock üçün bunun iki nəticəsi vacibdir.

Namespace obyektini dəyişmək olmaz. import * as analytics from "./analytics" xassələrinə yeni dəyər vermək və ya yenidən təyin etmək mümkün olmayan modul namespace obyekti verir; modulun içində analytics.trackEvent = fake TypeError atır. vi.spyOn(analytics, "trackEvent") Vitest-in Node, jsdom və happy-dom mühitlərində yenə işləyir, çünki buna Vitest-in module runner-i icazə verir; sənədlər bunu "zahirən ES Module" olan obyektə spy qoymaq adlandırır və bunun dəyişə biləcəyi barədə xəbərdarlıq edir. Modulların native olduğu Browser Mode-da isə alınmır: namespace "sealed-dir və yenidən konfiqurasiya oluna bilməz". Hər yerdə işləyən forma vi.mock("./analytics", { spy: true })-dur: Vitest modulu avtomatik mock edir, amma hər export-un real implementasiyasını saxlayır, ona görə real kod işləyərkən çağırışları yoxlaya bilirsən.

Eyni modulun içindəki çağırışlar tutulmur.

TypeScript
// analytics.ts
export function trackEvent(name: string, data: object) {
  navigator.sendBeacon("/events", JSON.stringify({ name, data }));
}

export function trackTaskCompleted(id: string) {
  trackEvent("task_completed", { id });
}

trackEvent-ə qoyulan spy və ya mock başqa modulların onu import edəndə gördüyünü dəyişir. trackTaskCompleted isə öz lokal binding-ini birbaşa çağırır, ona görə real funksiyanı çağırmağa davam edir. Vitest-in mocking bələdçisi bu tələni sadalayır: belə funksiyanı kənardan mock etmək mümkün deyil, "çünki ona birbaşa istinad olunur". İki həll yolu:

  • əvəz etmək istədiyin funksiyanı ayrıca modula köçür ki, çağıran onu import etsin və vi.mock onu dəyişə bilsin;
  • onu parametr kimi ötür (dependency injection): trackTaskCompleted(id, send = trackEvent), test isə öz send-ini ötürür.

Bütün bunlar vi.mock-a niyə təsir etmir. O, artıq yüklənmiş modulu dəyişmir. Əvəzedicini modul reyestrində heç kim modulu import etməmişdən əvvəl qeydiyyata alır; çağırışın yuxarı qaldırılması və faylın import-larının dinamik import-lara çevrilməsi də buna görədir. Bundan sonra hər import edən əvvəldən əvəzediciyə bağlanır; heç nəyə yeni dəyər vermək lazım olmur.

Bu, tez-tez rast gəlinən bir sürprizi də izah edir: test olunan kod referansı artıq götürübsə (modul səviyyəsində const send = analytics.trackEvent və ya başlanğıcda qeydiyyata alınan callback), sonra yaradılan spy həmin çağırışları görmür. vi.spyOn yalnız spy qurulandan sonra xassə vasitəsilə edilən çağırışları qeydə alır.

SeniorFramework

Modul mock-unu hər testdə dəyişmək

vi.mock hər faylda bir dəfə, import-lardan əvvəl işləyir. Ehtiyacların çoxunu bu ödəyir; modulu testdən testə dəyişməyin iki yolu var, sadəsindən başlayaraq:

1. Mock-un davranışını dəyiş. Modul funksiyalar export edirsə, onları bir dəfə mock et və qaytarılan dəyəri hər testdə təyin et:

TypeScript
import { isEnabled } from "./flags";

vi.mock("./flags", () => ({ isEnabled: vi.fn() }));

it("shows the new editor when the flag is on", () => {
  vi.mocked(isEnabled).mockReturnValue(true);
  render(<Editor />);
  expect(screen.getByRole("heading", { name: "New editor" })).toBeInTheDocument();
});

2. Modulu yenidən icra et. Kod asılılığı modul icra olunarkən oxuyursa (editor.ts-in yuxarısında const newEditor = flags.newEditor), mock-u sonradan dəyişməyin heç bir təsiri olmur: dəyər bir dəfə oxunub. Onda yuxarı qaldırılmayan və növbəti dinamik import()-a təsir edən vi.doMock-u modulun yenidən icra olunması üçün vi.resetModules() ilə birlikdə işlət:

TypeScript
beforeEach(() => {
  vi.resetModules();
});

it("uses the new editor when the flag is on", async () => {
  vi.doMock("./flags", () => ({ newEditor: true }));
  const { editorKind } = await import("./editor");
  expect(editorKind()).toBe("new");
});

it("keeps the old editor when the flag is off", async () => {
  vi.doMock("./flags", () => ({ newEditor: false }));
  const { editorKind } = await import("./editor");
  expect(editorKind()).toBe("old");
});

Faylın yuxarısındakı statik import-lar vi.doMock işləməmişdən əvvəl icra olunub, ona görə test olunan modul ondan sonra dinamik import olunmalıdır. vi.resetModules() modul keşini təmizləyir, mock reyestrini isə yox; qeydiyyatdakı mock-u vi.doUnmock(path) silir.

İkinci yol işləyir, amma test etmək çətin olan dizaynın əlamətidir: konfiqurasiyanı import zamanı oxuyan modul. Flag-i funksiyanın içində oxumaq (birinci yol) və ya onu prop yaxud arqument kimi ötürmək həm testi, həm də kodu sadələşdirir.

Mock-ları dürüst saxla. Hansı üsul olursa olsun, mock modulun yalnız sən onu yazdığın gün nə qaytardığını deyir. importOriginal()-dan başlayan və yalnız yan təsirli hissələri əvəz edən factory-lərə üstünlük ver ki, modulun qalan hissəsi real davranışını saxlasın; tiplərdən də istifadə et (vi.mock(import("./flags"), ...)) ki, real modulun forması dəyişəndə kompilyator bunu görsün.

SeniorKonsepsiya

Contract drift: mock-lar API-yə uyğun gəlməyəndə

Mock API davranışının, mock-un yazıldığı gün çıxarılmış surətidir. Backend done-un adını completed-ə dəyişəndə handler-lər hələ də done qaytarır, bütün testlər keçir, production-da isə bütün tapşırıqlar açıq görünür. Buna contract drift (müqavilənin sürüşməsi) deyilir: mock-lar nə qədər real görünürsə, testlər bir o qədər inamlı və bir o qədər yanlış olur.

Onu tutmağın yolları, təxminən ən ucuzundan başlayaraq:

Mock-ları API-nin tipləri ilə tiplə. Client-in tipləri API-nin sxemindən generasiya olunursa (məsələn, backend-in dərc etdiyi OpenAPI sənədindən), adı dəyişmiş sahə fixture-larda tip xətasına çevrilir. MSW handler-ləri generic tipləri Params, RequestBodyType, ResponseBodyType sırası ilə qəbul edir, onda HttpResponse.json() cavab tipinə uyğun olmalıdır:

TypeScript
import type { Task } from "../api/types";

http.patch<{ id: string }, { done: boolean }, Task>(`${API}/tasks/:id`, async ({ params, request }) => {
  const { done } = await request.json();
  return HttpResponse.json({ id: params.id, title: "Write the release notes", done });
});

Fixture-ları tətbiqin sxemindən keçir. Client cavabları sərhəddə yoxlayırsa (), məsələn, Zod sxemi ilə, fixture-ları testdə eyni sxemlə parse et. Real client-in rədd edəcəyi fixture o zaman pozulmuş müqaviləni gizlətmək əvəzinə CI-da sınır.

Fixture-ları bir yerdə qur. makeTask({ done: true }) kimi factory-lər o deməkdir ki, formanın dəyişməsi obyekti kopyalamış qırx handler yox, bir düzəliş tələb edir.

Contract testləri. Martin Fowler contract testini real servis (onun test instansiyası) üzərində işləyən və test double-ın servisi düzgün təmsil etdiyini yoxlayan test kimi təsvir edir; burada datanın dəyərlərindən çox formatı vacibdir. Onlar hər commit-də işləməli deyil; cədvəlləri servisin dəyişikliklərinə uyğunlaşır.

Bir neçə real end-to-end yoxlaması. Ən vacib ssenariləri real backend ilə, mock-suz kimi saxla. Onlar yavaşdır, ona görə sayları azdır, amma pozulmuş müqavilə istifadəçilər görməzdən əvvəl haradasa üzə çıxacaq.

Bir handler dəsti. Unit testlər, Storybook və lokal development (setupWorker vasitəsilə) hərəsi öz saxta API-sini saxlayırsa, sürüşə biləcək üç surət var. Bir handlers modulunu paylaş.

Məqsəd mock etməyi dayandırmaq deyil. Mock-lu sürətli testlər saniyələr içində rəy verir; yuxarıdakı yoxlamalar isə mock-ların production-da işləyən API-ni hələ də təsvir etdiyinə əmin olmaq üçündür.

SeniorMüsahibə məsləhətləri

Müsahibə üçün məsləhətlər

30 saniyəlik cavab. "Mən şəbəkə sərhədində mock edirəm, adətən MSW ilə: handler-lər serverin nə cavab verdiyini təsvir edir, setupServer Node-da sorğuları tutur, real fetch, wrapper və komponent isə hamısı işləyir. Xətaları, boş datanı və yavaş cavabları əhatə etmək üçün handler-i hər testdə server.use() ilə override edirəm, hər testdən sonra handler-ləri sıfırlayıram və heç bir handler-ə uyğun gəlməyən sorğuları xəta ilə dayandırıram. vi.mock-u analitika və ya feature flag-lər kimi şəbəkə olmayan modullar üçün işlədirəm və bilirəm ki, o, yuxarı qaldırılır və modulu hər import edən üçün əvəz edir. Contract drift-ə də diqqət edirəm: tiplənmiş fixture-lar, tətbiqin işlətdiyi eyni sxem və bir neçə mock-suz E2E test."

Gözlənilən suallar

  • Niyə fetch-i və ya öz API modulunu mock etməyək? Hər ikisi testi səhvin ən çox ehtimal olunduğu koddan yuxarıda kəsir və onu kodun çağırış formasına bağlayır. Şəbəkə səviyyəsindəki mock davranışı saxlayan refaktorinqlərdən sağ çıxır.
  • Xəta vəziyyətini necə test edirsən? 500 və HttpResponse.error() ilə server.use(); izah et ki, 500-də fetch ok: false ilə resolve olur, şəbəkə xətası isə onu reject edir.
  • vi.mock-un yuxarı qaldırılması nə deməkdir? O, import-lardan əvvəl işləyir; factory faylın dəyişənlərini işlədə bilməz, vi.hoisted ilə yaradılanlar istisnadır; iç-içə yazılmış vi.mock Vitest 5-də xəta atır; yuxarı qaldırılmayan variant vi.doMock-dur.
  • Adlı export-a qoyduğum spy niyə çağırışı görmür? Çağıran eyni moduldadır və öz lokal binding-ini işlədir, ya da modul sistemi namespace xassələrini yenidən təyin etməyə icazə vermir. { spy: true } ilə vi.mock işlət, modulu böl və ya asılılığı inject et.
  • Mock-ların hələ də backend-ə uyğun olduğunu necə bilirsən? Generasiya olunmuş tiplər, ortaq sxem yoxlaması, contract testləri, bir neçə real E2E yoxlaması.

Bal itirməyə səbəb olan səhvlər

  • İstifadəçinin gördüyünü yoxlamaq əvəzinə sorğunun göndərildiyini yoxlamaq.
  • Komponentin import etdiyi hər şeyi mock etmək; o zaman test kodu yox, mock-ları yoxlayır.
  • resetHandlers() və ya unstubAllGlobals()-ı unudub "flaky" nəticəni runner-in boynuna atmaq.
  • onUnhandledFrame-i (MSW 2-də onUnhandledRequest) default dəyərdə qoymaq; onda səhv URL səssizcə real şəbəkəyə çıxır.

Senior səviyyəni göstərən məqamlar

Qayda yox, kompromisi izah et: konkret asılılıq üçün hansı seam-i seçərdin və niyə, həmin seam-dəki sınma sənə nə deyir və saxta cavabların production-dan uzaqlaşmasının qarşısını necə alırsan. Qeyd et ki, eyni handler-lər testlərə, Storybook-a və lokal development-ə xidmət edə bilər, beləliklə üç yox, bir saxta API saxlanılır.

MiddleYoxlama siyahısı

Mock-ları review edərkən nəyi yoxlamalı

Şəbəkəni və ya modulları mock edən testləri yazmadığın kodda — komanda yoldaşının pull request-ində, kitabxananın nümunəsində, AI assistentin təklifində — review edəndə bu siyahını işlət. Mock-lardakı səhvlər nadir hallarda testi sındırır: real tətbiq sınarkən testlər keçir, ya da dəyişikliklə əlaqəsi olmayan səbəblərdən sınır.

  • Şəbəkə şəbəkə sərhədində mock olunubmu? Komandanın öz API wrapper-inin vi.mock-u və ya vi.stubGlobal("fetch") URL qurulmasını, status yoxlamalarını və parse etməni ötürür; MSW handler-lərinə üstünlük ver və test olunan kodun hələ də real fetch-i çağırdığını yoxla.
  • Heç bir handler-ə uyğun gəlməyən sorğular xəta verirmi? listen() çağırışında onUnhandledFrame: "error"-u (MSW 2-də onUnhandledRequest) axtar; default "warn" ilə səhv URL real şəbəkəyə çıxır və test ondan asılı olur.
  • Hər override testdən sonra sıfırlanırmı? afterEach-də server.resetHandlers(), vi.unstubAllGlobals() və ya unstubGlobals: true, spy və implementasiyalar üçün restoreMocks və ya mockReset. Faylı bir testdə .only ilə və onsuz işə sal: fərqli nəticələr sızan state deməkdir.
  • Xəta və loading vəziyyətləri düzgün uğursuzluqla test olunurmu? 500-ə response.ok-un emalı, şəbəkə xətasına (HttpResponse.error()) catch lazımdır; hər birinə bir test, üstəgəl boş cavab kodun onları emal edib-etmədiyini göstərir.
  • Test istifadəçinin gördüyünü yoxlayırmı? expect(fetch).toHaveBeenCalledWith(...) və ya handler-in çağırıldığını yoxlamaq nəticəni yox, çağırışı test edir; request body-ni handler-də yoxla, assertion-larla isə ekranı yoxla.
  • Modul mock-u həqiqətən işlədiləcəkmi? vi.mock üst səviyyədə olmalıdır, factory-də isə vi.hoisted ilə yaradılanlardan başqa xarici dəyişən olmamalıdır; export-a qoyulan spy eyni modulun içindəki çağırışları görmür.
  • Fixture-lar real API-yə uyğundurmu? Onlar API-nin tipləri ilə tiplənməli və ya tətbiqin sxemi ilə parse olunmalı, ortaq factory-lərlə qurulmalı və ssenarinin ən azı bir mock-suz E2E testi ilə dəstəklənməlidir.

Özünü yoxla

  • Məşq

    Kodun nəticəsini təxmin et, açıq müsahibə suallarına cavab ver və özünü qiymətləndir.

    3 nəticə sualı · 4 açıq sual

  • Quiz

    İzahlı test sualları və yekun nəticə.

    7 sual