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

Testləşdirmə

Asinxron testlər və flaky testlər

Asinxron kodu yalançı uğurlar və təsadüfi uğursuzluqlar olmadan test etmək: hər şeyi await etmək, findBy və waitFor, act() xəbərdarlığının mənası, Vitest fake timer-ləri və onların async variantları, testlərin niyə flaky olduğu (vaxt, paylaşılan state, sıra, şəbəkə, təsadüfilik, saat qurşaqları) və onları retry əvəzinə necə tapıb düzəltmək.

JuniorMiddleSeniorYenilə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 Junior səviyyəsindən başlayır.

JuniorTipik səhvlər

Heç nəyi yoxlamadan keçən testlər

Test runner yalnız test funksiyasının ona qaytardığını qiymətləndirə bilir. Funksiya asinxron iş bitməmiş qayıdırsa, runner heç bir xəta görmür və testi keçmiş sayır.

TypeScript
test("loads the user", () => {
  fetchUser(1).then((user) => {
    expect(user.name).toBe("Ana");
  });
});

Funksiya sorğunu başladır və dərhal undefined qaytarır, ona görə test keçir. Assertion sonra işləyir, ya da ümumiyyətlə işləmir. Düşəndə xəta heç kimin emal etmədiyi rejected promise olur: Vitest emal olunmamış rejection-ları bu testin uğursuzluğu kimi yox, bütün run-ın xətası kimi bildirir; test faylı sorğudan əvvəl bitsə, assertion heç vaxt işləməyə bilər.

Testi yoxladığı işi gözləməyə məcbur et:

TypeScript
test("loads the user", async () => {
  const user = await fetchUser(1);
  expect(user.name).toBe("Ana");
});

Promise-i qaytarmaq (return fetchUser(1).then(...)) da işləyir, amma async/await daha asan oxunur.

UI testlərində eyni bug

  • await olmadan user.click(button): növbəti sətir klik bitməmiş işləyir. expect(screen.queryByText("Could not delete")).not.toBeInTheDocument() kimi yoxluq yoxlaması onda keçir, çünki hələ heç nə baş verməyib.
  • await olmadan ayrıca sətir kimi yazılmış screen.findByText("Saved"): onu heç nə gözləmir və nəticəni heç nə yoxlamır.
  • await olmadan waitFor(() => expect(...)): onun içindəki timeout testi heç vaxt uğursuz edə bilməz.
  • await olmadan expect(promise).resolves.toBe(...): Vitest bunu aşkar edir və testi sonunda uğursuz edir, digərləri isə gözdən qaçır.

Qoruyucular

  • expect.hasAssertions() heç bir assertion işləməyən testi uğursuz edir; expect.assertions(2) isə dəqiq say tələb edir. Hər ikisi ilə yuxarıdakı ilk nümunə düşür: test bitəndə heç bir assertion işləməyib. expect.requireAssertions config seçimi "ən azı bir" qaydasını bütün testlərə tətbiq edir.
  • typescript-eslint-in no-floating-promises qaydası await olunmayan, qaytarılmayan və emal olunmayan promise ifadələrini bildirir.
  • eslint-plugin-testing-library-də findBy, user-event və waitFor üçün await-async-queries, await-async-events və await-async-utils qaydaları var.
  • Hər yeni testin bir dəfə düşdüyünü öz gözünlə gör. Heç vaxt düşdüyünü görmədiyin test heç nəyi yoxlamaya bilər.
JuniorKonsepsiya

UI-ı gözləmək: findBy və waitFor

UI sorğudan, taymerdən və ya effektdən sonra dəyişəndə test gözləməlidir. Ağla gələn ilk yol sabit fasilədir:

TSX
await new Promise((resolve) => setTimeout(resolve, 500));
expect(screen.getByText("Saved")).toBeInTheDocument();

Sürətli noutbukda bu, vaxt itkisidir; yüklü CI maşınında isə 500 ms bəzən çatmır və test flaky olur. Martin Fowler-in məsləhəti asinxron cavabları heç vaxt sadəcə sleep ilə gözləməmək, əvəzində callback və ya polling işlətməkdir. Testing Library-nin gözləmə köməkçiləri polling-i sənin yerinə edir.

findBy

TSX
await user.click(screen.getByRole("button", { name: "Save" }));
expect(await screen.findByRole("status")).toHaveTextContent("Saved");

findBy element görünən kimi resolve olur, default olaraq 1000 ms-dən sonra isə reject olur. Gözləmə seçimlərini üçüncü arqument kimi qəbul edir: findByRole("status", {}, { timeout: 3000 }).

waitFor

waitFor(callback) ümumi formadır. Callback-i dərhal işə salır, sonra hər 50 ms-dən bir və DOM hər dəfə dəyişəndə təkrarlayır; bu, callback xəta atmağı dayandırana və ya timeout (1000 ms) bitənə qədər davam edir. Sonra sonuncu xəta ilə reject olur.

TSX
await waitFor(() => expect(onSave).toHaveBeenCalledWith({ name: "Ana" }));

false qaytarmaq kifayət deyil: təkrar cəhd olunması üçün callback xəta atmalıdır. expect-in onun içində olmasının səbəbi budur. Yox olmalı olan element üçün waitForElementToBeRemoved(() => screen.queryByText("Loading...")) element itənə qədər gözləyir. Element əvvəldən yoxdursa, o, dərhal xəta atır və bu, səhv şeyi gözləyən testi tutur.

Gözləməni etibarlı saxlayan qaydalar

Kent C. Dodds bunları Testing Library ilə bağlı tipik səhvlər sırasında sadalayır:

  • waitFor ilə getBy əvəzinə findBy-a üstünlük ver. Davranış eynidir, kod qısadır, xəta mesajı daha yaxşıdır.
  • Heç vaxt boş callback ötürmə (await waitFor(() => {})). O, heç nəyi yoxlamır və asinxron məntiq dəyişən kimi test sınır. Konkret assertion gözlə.
  • Callback-ə bir assertion qoy. Heç vaxt keçməyəcək assertion eyni callback-dədirsə, waitFor uğursuzluğu bildirməzdən əvvəl timeout bitənə qədər təkrar cəhd edir. Qalanlarını gözləmədən sonra yoxla, orada dərhal düşsünlər.
  • Yan təsirləri callback-dən kənarda saxla. waitFor-un içindəki klik hər təkrar cəhddə yenidən işləyir.
MiddleFramework

act() xəbərdarlığı nə deməkdir

React-in act() funksiyası onun içində başlayan yenilənmələrin və effektlərin növbəti sətir işləməzdən əvvəl tətbiq olunmasını təmin edir, yəni istifadəçinin ekranı görəcəyi andakı vəziyyəti yaradır. React Testing Library render-i və fireEvent-i act-ə bükür, user-event-in event-ləri də eyni wrapper-dən keçir, waitFor və findBy gözləyərkən isə o, act yoxlamasını söndürür ki, gözləmə zamanı baş verən yenilənmələr xəbərdarlıq yaratmasın. Testlərin çoxu act-i heç vaxt özü çağırmır.

Xəbərdarlıq belə görünür:

Text
An update to ProfileForm inside a test was not wrapped in act(...).

Bu o deməkdir ki, React testdə heç nəyin gözləmədiyi state yenilənməsi görüb. Adətən test assertion-larını edib irəli gedir, komponentin başlatdığı promise isə hələ gözləmədə olur və sonra state dəyişir. Test UI-ı o sabitləşməmiş yoxlayıb, yenilənmə isə testin idarə etmədiyi anda baş verir.

TSX
test("saves the profile", async () => {
  const user = userEvent.setup();
  const onSave = vi.fn().mockResolvedValue(undefined);
  render(<ProfileForm onSave={onSave} />);

  await user.click(screen.getByRole("button", { name: "Save" }));
  expect(onSave).toHaveBeenCalled();
  // onSave bu sətirdən sonra resolve olur və form "Saved" qoyur: xəbərdarlıq
});

Düzəliş daha çox act deyil, istifadəçinin gözləyəcəyini gözləməkdir:

TSX
  expect(await screen.findByRole("status")).toHaveTextContent("Saved");

İndi yenilənmə Testing Library gözləyərkən baş verir və test son vəziyyəti də yoxlayır.

act-i özün nə vaxt çağırırsan

  • Fake timer-lər: onları irəli çəkmək heç bir Testing Library çağırışından kənarda state dəyişə bilən callback-ləri işə salır: act(() => { vi.advanceTimersByTime(5000); }).
  • Testin birbaşa yaratdığı yenilənmələr, məsələn store-un metodunu və ya renderHook nəticəsinin funksiyasını çağırmaq.

Asinxron iş üçün react.dev async formanı tövsiyə edir: await act(async () => { ... }). React 19-da act-i react-dən import et; react-dom/test-utils-dən köhnə import deprecated-dir.

Mühit bayrağı

React 18 globalThis.IS_REACT_ACT_ENVIRONMENT bayrağını gətirdi; React act-dən kənar yenilənmələri yalnız bu bayraq true olanda bildirir. React Testing Library onu qlobal beforeAll-da qoyur, ona görə Vitest-də ya globals: true təyin et, ya da bayrağı setup faylında özün qoy. Əks halda xəbərdarlıq heç vaxt görünmür, onun göstərdiyi problem isə gizli qalır.

Xəbərdarlığı susdurma. O, testinin gözləmədiyi yenilənməni göstərir və sonradan flaky testə çevrilən çox vaxt məhz həmin yenilənmə olur.

MiddleFramework

Vitest-də fake timer-lər

5 saniyədən sonra gizlənən bildiriş, 300 ms-lik və ya 15 dəqiqədən sonra çıxan sessiya xəbərdarlığı: bunları real vaxtda gözləmək testləri yavaşladır, onlarla yarışmaq isə testləri flaky edir. taymer funksiyalarını yalnız test irəli çəkəndə hərəkət edən saatla əvəz edir.

TSX
beforeEach(() => {
  vi.useFakeTimers();
});

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

test("hides the notice after 5 seconds", () => {
  render(<SavedNotice />);

  act(() => {
    vi.advanceTimersByTime(4999);
  });
  expect(screen.getByRole("status")).toHaveTextContent("Saved");

  act(() => {
    vi.advanceTimersByTime(1);
  });
  expect(screen.queryByRole("status")).not.toBeInTheDocument();
});

Test millisaniyələr çəkir və sərhədin hər iki tərəfini yoxlayır. act ona görə var ki, taymer callback-i state-i heç bir Testing Library çağırışından kənarda dəyişir.

Nələr saxtalaşdırılır

vi.useFakeTimers() setTimeout, setInterval, setImmediate, onların clear funksiyalarını, Date-i, default olaraq isə mühitin təqdim etdiyi bu növdən olan digər hər şeyi, məsələn requestAnimationFrame və performance-ı saxtalaşdırır; istisna process.nextTick və queueMicrotask-dır. Promise-lər taymer deyil: promise callback-ləri yenə də kimi, öz qaydası ilə işləyir.

Saatı irəli çəkmək

  • vi.advanceTimersByTime(ms): ms ərzində vaxtı çatan bütün taymerləri işə salır.
  • vi.advanceTimersToNextTimer(): növbəti taymerə keçir və onu işə salır.
  • vi.runOnlyPendingTimers(): artıq planlaşdırılmış taymerləri işə salır, onların yaratdığı yeniləri yox.
  • vi.runAllTimers(): taymer qalmayana qədər işə salır. Sonsuz interval onu 10 000 taymerdən sonra xəta atmağa məcbur edir (loopLimit seçimi).
  • vi.getTimerCount(): neçə taymerin gözlədiyini göstərir. Komponentin özündən sonra təmizlik etdiyini yoxlamaq üçün faydalıdır.
  • vi.setSystemTime(date): heç bir taymeri işə salmadan Date.now() və new Date()-in qaytardığını dəyişir. "Bu gün" və "ayın sonu" halları üçün alət budur.

Söndürmək

vi.useRealTimers() real funksiyaları geri qaytarır, hələ planlaşdırılmış taymerlər isə atılır. Testing Library-nin bələdçisi əvvəlcə gözləyən taymerləri işə salmağı təklif edir ki, yazmadığın kitabxananın planlaşdırdığı iş səssizcə itməsin. Real taymerləri hər testdən sonra bərpa et; növbəti testə sızan fake timer-lər çaşdırıcı uğursuzluqların klassik səbəbidir.

Fake timer-lər həmişə daha yaxşı seçim deyil. Gecikmə qısadırsa, real taymerlər və findBy çox vaxt daha sadədir.

MiddleTipik səhvlər

Fake timer-lər promise-lərlə qarşılaşanda

Fake timer-lərlə bağlı sürprizlərin çoxu taymerləri və promise-ləri qarışdıran koddan gəlir. Status yoxlayan poller-ə bax:

TypeScript
export function startPolling(load: () => Promise<string>, show: (status: string) => void) {
  async function poll() {
    const status = await load();
    show(status);
    if (status !== "done") setTimeout(poll, 1000);
  }
  setTimeout(poll, 1000);
}

Fake timer-lər aktivdir, load isə ardıcıl olaraq "queued", "running" və "done" qaytarır. Test vi.advanceTimersByTime(3000) çağırır və üç yenilənmə gözləyir, amma bir dənə alır. İlk poll 1000 ms-də işə düşür və await load()-da dayanır; poll-un qalanı promise callback-idir, yəni microtask-dır, microtask-lar isə yalnız sinxron advanceTimersByTime qayıtdıqdan sonra işləyir. O vaxta qədər o, aralıqda başqa taymer tapmayıb, ona görə saat sadəcə 3000 ms-ə keçib. Növbəti taymer daha sonra, yeni vaxtdan planlaşdırılır. Bu, adi qaydada işləyən -dur: taymerlər macrotask-dır, promise callback-ləri isə onların arasında işləyir.

Async variantlar bunu düzəldir. Vitest sənədlərinə görə vi.advanceTimersByTimeAsync asinxron qurulan taymerləri də əhatə edir: taymerlərin arasında promise callback-lərinin işləməsinə imkan verir. advanceTimersByTime, advanceTimersToNextTimer, runAllTimers və runOnlyPendingTimers-in hər birinin Async versiyası var. React testində onu async act-ə bük:

TSX
await act(async () => {
  await vi.advanceTimersByTimeAsync(3000);
});

Fake timer-lər altında user-event və Testing Library

Hər ikisi Jest-in fake timer-ləri nəzərə alınaraq qurulub və bu, Vitest-də özünü göstərir:

  • user-event input-lar arasında setTimeout ilə fasilə verir (delay seçimi, default 0), fake timer-lər altında isə bu timeout-u heç nə işə salmır. Onun sənədləri saatını ötürməyi deyir, userEvent.setup({ advanceTimers: vi.advanceTimersByTime }), köhnə delay: null üsulunu isə məsləhət görmür.
  • waitFor, findBy və user-event çağırışlarının hamısının keçdiyi React Testing Library async wrapper-i qısa setTimeout ilə bitir və onu yalnız Jest-in fake timer-lərini aşkar edəndə irəli çəkir. Vitest-in fake timer-ləri altında bu çağırışlar advanceTimers qoyulsa belə test timeout-a düşənə qədər ilişib qala bilər. Bu, React Testing Library repozitoriyasında açıq issue-dur.

Etibarlı yol: fake timer tələb edən testləri sinxron saxla, qarşılıqlı əlaqə üçün fireEvent, vaxtı irəli çəkmək üçün act(() => { vi.advanceTimersByTime(...); }), yoxlamaq üçün isə getBy işlət. user-event və findBy lazım olan testlərə real taymerlər ver. vi.useFakeTimers({ shouldAdvanceTime: true }) də onları ilişib qalmaqdan qurtarır, amma onda real vaxt saxta saata sızır. Vitest-in öz vi.waitFor, vi.waitUntil və expect.poll köməkçiləri isə gözləyərkən fake timer-ləri irəli çəkir.

Fake timer-ləri test olunan kod nəyisə planlaşdırmazdan əvvəl, adətən render-dən əvvəl yandır. Real setTimeout ilə yaradılmış taymer real qalır.

SeniorTipik səhvlər

Testlər niyə flaky olur

eyni kod üzərində gah keçir, gah düşür. Martin Fowler deterministik olmayan testləri faydasız və "bütün test dəstini tamamilə məhv edə bilən, sürətlə yayılan infeksiya" adlandırır: insanlar qırmızının bəzən heç nə demədiyini öyrənəndə uğursuzluqları oxumaq əvəzinə yenidən işə salırlar və real bug-lar keçib gedir.

Testin nəticəsi onun idarə etmədiyi nədənsə asılı olanda test flaky olur. Ən çox rast gəlinən səbəblər:

  • Vaxt. Sabit sleep-lər, asinxron iş bitməmiş işləyən assertion-lar, noutbuka uyğun gələn, yüklü CI maşınına isə çatmayan timeout-lar, hələ davam edən animasiyalar.
  • Testlər arasında paylaşılan state. Vitest hər test faylına ayrıca mühit verir, faylın içindəki testlər isə bir-birinin ardınca işləyir və modul state-ini, cleanup yoxdursa DOM-u, restoreMocks və ya əl ilə bərpa onları sıfırlamırsa mock-ları, stub edilmiş qlobal dəyişənləri və brauzer yaddaşını paylaşır.
  • Sıradan asılılıq. Test yalnız ona lazım olan məlumatı əvvəlki test yaratdığı üçün keçir, ya da arxasında nəsə qoyub gedən testdən sonra düşür.
  • Real şəbəkə. Cavablar yavaş gəlir, serverlər işləmir, rate limit-lər işə düşür, məlumat dəyişir.
  • Təsadüfilik. Math.random(), generasiya olunan id-lər, sabit seed-i olmayan təsadüfi test datası.
  • Tarixlər və saat qurşaqları. "Bu gün", ayın sonu, yay vaxtına keçid, maşının saat qurşağı.
  • Sızmalar. Bir testin taymeri və ya sorğusu növbəti testin vaxtında işə düşür.
  • Paylaşılan resurslar. Paralel işləyən fayllar eyni port-dan, fayldan və ya verilənlər bazasından istifadə edir.

Saat qurşağından yaranan flaky test

TypeScript
export function formatDueDate(iso: string) {
  return new Date(iso).toLocaleDateString("en-GB");
}

test("formats the due date", () => {
  expect(formatDueDate("2026-03-01T22:30:00Z")).toBe("02/03/2026");
});

Bakıdakı noutbukda (UTC+4) bu an 2 martın 02:30-udur və test keçir. UTC-də işləyən CI runner-ində isə bu, 1 martın 22:30-udur, funksiya "01/03/2026" qaytarır və test düşür. Heç kim kodu dəyişməyib. Düzəliş məhsul qərarı ilə başlayır: son tarix hansı saat qurşağına aiddir? Sonra onu açıq şəkildə ötür, toLocaleDateString("en-GB", { timeZone: "Asia/Baku" }), və nəticə artıq maşından asılı olmur. Test dəstini sabit TZ ilə işə salmaq bütün maşınlarda eyni nəticə verir, amma başqa saat qurşaqlarındakı real istifadəçilərin görəcəyi bug-ları da gizlədir.

Hər flaky test testin günahı deyil

Bəzən test düzdür, məhsulda isə race var: ikiqat göndərmə, unmount-dan sonra işləyən effekt, istənilən sırada bitə bilən iki sorğu. Testi flaky adlandırmazdan əvvəl yoxla ki, uğursuz nəticə istifadəçinin də başına gələ bilməz.

SeniorKonsepsiya

Flaky testi tapmaq

CI-dakı flaky uğursuzluğu təkrarlaya bilmirsənsə, onu debug etmək çətindir. Əvvəlcə onu istədiyin vaxt düşməyə məcbur et.

Testi dəfələrlə işə sal

Shell
vitest run src/cart.test.ts --repeats=50

--repeats hər testi göstərilən sayda əlavə dəfə işə salır, istənilən təkrarın düşməsi isə testi uğursuz edir. Debug edərkən bir test də öz seçimlərində { repeats: 50 } təyin edə bilər. 50 dəfədən 2-sində düşən test artıq üzərində işləyə biləcəyin bir şeydir.

Sıranı dəyiş

Shell
vitest run --sequence.shuffle
vitest run --sequence.shuffle --sequence.seed=1234

Shuffle faylları və testləri təsadüfi sırada işə salır və başqa testin əvvəl işləməsindən asılı olan testləri üzə çıxarır. Sıranı seed müəyyən edir. Öz seed-ini ötür və run-lar arasında onu dəyiş; hansısa düşəndə, düzəldərkən həmin sıranı təkrarlamaq üçün eyni seed ilə yenidən işə sal.

İki sürətli eksperiment axtarış dairəsini daraldır:

  • Testi tək işə sal: -t "adds an item". Tək keçir, faylla birlikdə düşürsə, başqa test arxasında state qoyur. Tək düşür, faylda keçirsə, test əvvəlki testin qurduğu nədənsə asılıdır.
  • Onu qonşuları ilə başqa sırada işə sal, sonra günahkar aydın olana qədər faylı yarıya böl.

CI şəraitini yenidən yarat

  • Saat qurşağı və saat: TZ=UTC vitest run, ayın sonu kimi tarix halları üçün isə vi.setSystemTime.
  • Yük: CI maşınları daha yavaşdır və çoxlu worker işlədir. Paralel faylların paylaşılan resurs üstündə toqquşub-toqquşmadığını görmək üçün daha az worker və ya --no-file-parallelism sına, vaxtla bağlı fərziyyələri üzə çıxarmaq üçün isə yüklü maşında işə sal.
  • Sızmalar: --detectAsyncLeaks test faylının işlək qoyub getdiyi taymerləri və digər asinxron resursları bildirir. Testləri xeyli yavaşladır, ona görə yalnız debug zamanı işlət.

Sübutları oxu

Uğursuzluğun əslində nə dediyinə bax: hansı assertion, hansı dəyər, hansı vaxt. Bir neçə uğursuz run-ı müqayisə et. Uğursuzluq həmişə eyni səhv dəyəri göstərirsə, state-ə və ya məlumata bax; "Unable to find" və ya timeout göstərirsə, vaxta bax. Run-lar arasında təkrarlanan qanunauyğunluq çox vaxt səbəbi kodu oxumaqdan daha tez göstərir.

SeniorKonsepsiya

Flaky testləri retry əvəzinə düzəltmək

Səbəbi biləndə düzəliş adətən mexaniki olur:

SəbəbDüzəliş
Sabit sleep, vaxtından əvvəl assertionŞərti gözlə: findBy, waitFor, expect.poll
Başqa testdən qalmış statebeforeEach/afterEach-də sıfırla; restoreMocks, unstubGlobals, cleanup; hər test üçün təzə məlumat
Real şəbəkəOnu şəbəkə və ya modul səviyyəsində mock et
Saat və saat qurşağıvi.setSystemTime; kodda açıq timeZone
TəsadüfilikGeneratoru inject et və ya seed ver; dəqiq dəyərləri yox, xassələri yoxla
Sızan taymerlər və ya sorğularKodu düzəlt: cleanup zamanı taymerləri təmizlə, sorğuları abort et

Hər düzəliş testi əvvəllər asılı olduğu nəyisə idarə etməyə məcbur edir. Səbəb məhsuldakı race çıxsa, məhsulu düzəlt; test haqlı idi.

Retry son çarədir

TypeScript
export default defineConfig({
  test: { retry: 3 },
});

Qlobal retry qırmızı build-ləri yaşıla çevirir və heç nə öyrətmir. Real race-ləri səndən gizlədir, istifadəçilər isə onlarla yenə qarşılaşır; düşən test dəstlərini yavaşladır, təkrar işə salınan hər test də vaxt aparır. Nəzarətindən kənarda olan nəsə həqiqətən etibarsızdırsa, məsələn end-to-end run-dakı xarici servis, retry-ı yalnız onunla məhdudlaşdır. retry count, delay və condition regex-i olan obyekt də ola bilər, onda yalnız uyğun gələn xətalar təkrarlanır:

TypeScript
retry: { count: 2, condition: /ECONNREFUSED/ }

Karantin

Martin Fowler deterministik olmayan testləri əsas pipeline-dan kənara, karantinə çıxarmağı, "amma karantindəki testləri tez düzəltməyi" məsləhət görür. O, limit də təklif edir, məsələn az sayda test və ya ən çoxu bir həftə, ki karantin qəbiristanlığa çevrilməsin. Vitest-in test tag-ları bunun sadə yolunu verir: testi config-də təyin olunmuş flaky tag-ı ilə işarələ və əsas test dəstini vitest --tags-filter="!flaky" ilə işə sal.

TypeScript
test("syncs the cart", { tags: ["flaky"] }, async () => {
  // ...
});

Adi test.skip də işləyir, əgər onun yanında əlaqəli issue və sahibi varsa. Hər iki halda karantindəki test test etməkdən imtina qərarı yox, son tarixi olan məlum bug-dır.

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

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

30 saniyəlik cavab. "Asinxron test yoxladığı işi gözləməlidir: hər şeyi await et, sleep əvəzinə findBy və ya waitFor işlət, waitFor-a isə heç vaxt yan təsir qoyma. act xəbərdarlığı testin gözləmədiyi state yenilənməsinin baş verdiyini bildirir. Fake timer-lər vaxtdan asılı kodu sürətli və deterministik edir, amma promise-lər olanda async variantlar lazımdır. Flaky testlər vaxtdan, paylaşılan state-dən, sıradan, şəbəkədən, təsadüfilikdən və saatdan yaranır. Onları repeats və qarışdırılmış sıra ilə təkrarlayıram, səbəbi düzəldirəm, retry və karantini isə yalnız qısamüddətli tədbir kimi işlədirəm."

Gözlənilən suallar

  • Kod pozuq olduğu halda bu test niyə keçir? Heç kimin await etmədiyi və ya qaytarmadığı promise; düzəlişi və expect.hasAssertions()-ı göstər.
  • waitFor necə işləyir? Callback-i dərhal, sonra hər 50 ms-dən bir və DOM dəyişəndə işə salır, bu, xəta atmağı dayandırana və ya 1000 ms keçənə qədər davam edir; təkrar cəhd üçün callback xəta atmalıdır.
  • act xəbərdarlığı nə deməkdir və onu necə düzəldirsən? Heç bir act-in əhatə etmədiyi yenilənmə; hər şeyin ətrafına act qoymaq əvəzinə nəticədə yaranan UI-ı findBy ilə gözlə.
  • 5 saniyəlik timeout-u necə test edirsən? Fake timer-lər, 4999 və 5000 ms-ə qədər irəli çək, hər iki tərəfi yoxla.
  • Test CI-da 20 run-dan birində düşür. Nə edirsən? --repeats və --sequence.shuffle ilə təkrarla, tək işə sal, CI-ın saat qurşağını və yükünü təkrarla, sonra səbəbi düzəlt.
  • Retry-ları yandıraq? Qlobal yox; onların nəyi gizlətdiyini və dar retry-ın nə vaxt məqbul olduğunu izah et.

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

  • İlk fikir kimi "1000 ms-lik setTimeout əlavə et" və ya "timeout-u artır" demək.
  • Xəbərdarlığı susdurmaq üçün hər şeyi act-ə bükmək.
  • advanceTimersByTime-ın await-dən sonrakı kodu niyə işə salmadığını bilməmək.
  • Flaky olmanı testdəki və ya məhsuldakı bug yox, bədbəxt təsadüf saymaq.

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

Test dəstindən sistem kimi danış. Flaky olmanı yaddaşla yox, CI tarixçəsi ilə ölç. Əsas branch-ı etibarlı saxla: sahibi və son tarixi olan karantin, asılı qalan promise-ləri və await olunmamış query-ləri tutan lint ayarları, config-də cleanup və restoreMocks, məlum saat qurşağında işləyən CI. Bunu da qeyd et ki, bəzi flaky testlər yalnız build üçün yox, istifadəçilər üçün də düzəltməyə dəyən məhsul race-ləridir.

JuniorYoxlama siyahısı

Asinxron testləri review edərkən nəyi yoxlamalı

Yazmadığın asinxron testləri (komanda yoldaşının pull request-ini, kitabxananın nümunəsini, AI assistentin təklifini) review edəndə bu siyahıdan istifadə et. Düzgün gözləməyən asinxron test ya heç nəyi yoxlamadan keçir, ya da təsadüfi düşür və hər ikisi sonradan indi qənaət etdiyindən baha başa gəlir.

  • Hər promise await olunub və ya qaytarılıbmı? return-süz .then(-ə, await-siz user. və findBy çağırışlarına və await-siz waitFor-a bax. Test olunan kodu sil və testi işə sal: o, düşməlidir.
  • Test sabit vaxtı yox, şərti gözləyirmi? Testi keçirmək üçün setTimeout fasiləsi və ya artırılmış timeout testin kodla yarışdığını göstərir; əvəzində findBy, waitFor və ya expect.poll olmalıdır.
  • waitFor yalnız assertion-lar üçün işlədilibmi? Callback-in içində klik, render və ya sorğu yoxdur, hər callback-də bir assertion var və boş callback heç vaxt yoxdur.
  • Fake timer-lər düzgün qurulub və söndürülübmü? render-dən əvvəl yandırılıb, afterEach-də bərpa olunub, promise-lər olan yerdə Async variantlar işlədilib və heç bir findBy, waitFor və ya user-event çağırışı Vitest-in saxta saatını gözləyib qalmır.
  • Hər test ona lazım olan state-i özü yaradırmı? Başqa testin məlumatına söykənmir; mock-lar, qlobal dəyişənlər və DOM testlər arasında sıfırlanır. Yoxlamaq üçün faylı --sequence.shuffle ilə işə sal.
  • Vaxt, saat qurşağı, təsadüfilik və şəbəkə testin nəzarətindədirmi? vi.setSystemTime, açıq timeZone, seed verilmiş və ya inject olunmuş təsadüfi mənbə, mock edilmiş sorğular. Komandan başqa saat qurşağında işləyirsə, testləri bir dəfə TZ=UTC ilə işə sal.
  • Hər retry-ın və ya skip-in səbəbi varmı? Dar şərt və ya sahibi olan əlaqəli issue; qlobal retry real problemləri gizlədir.

Ö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.

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

  • Quiz

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

    7 sual