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

Testləşdirmə

Nəyi və hansı səviyyədə test etməli

Testlər nə üçündür və onları hansı səviyyədə yazmalı: unit, inteqrasiya və end-to-end testlər və hər birinin qiyməti, test piramidası və testing trophy, implementasiya detallarının yox, davranışın yoxlanması, nəyi test etməməli, code coverage-in nəyi ölçdüyü, CI-da və code review-da reqressiya testləri.

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.

Başlamazdan əvvəl

İlkin şərt yoxdur.

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

JuniorKonsepsiya

Testləri niyə yazırıq

Test sənin kodunun bir hissəsini işə salıb nəticəni avtomatik yoxlayan koddur. Onu bir dəfə yazırsan, Vitest kimi test runner isə hər dəyişiklikdən sonra onu yenidən, bir neçə saniyəyə və hər dəfə eyni qaydada işə salır.

TypeScript
import { expect, test } from "vitest";
import { cartTotal } from "./cart";

test("adds up price times quantity", () => {
  const items = [
    { price: 4, quantity: 2 },
    { price: 10, quantity: 1 },
  ];
  expect(cartTotal(items)).toBe(18);
});

Bunu cart.ts-in yanında cart.test.ts adı ilə saxla, Vitest-i quraşdır (npm install -D vitest) və npx vitest əmrini işə sal. Vitest adı *.test.* və ya *.spec.* olan faylları tapır, onlardakı hər test-i işə salır və hansılarının uğursuz olduğunu bildirir. expect(value).toBe(18) assertion-dır: dəyər 18 deyilsə, xəta atır və test uğursuz olur. Öz kompüterində Vitest bundan sonra faylları izləməyə davam edir və faylı saxlayanda testləri yenidən işə salır; CI-da isə bir dəfə işləyib çıxır.

Testlər sənə nə verir

  • Kodu dəyişməyə əminlik. Testlər olmadan hər refaktorinq, asılılığın yenilənməsi və ya bug düzəlişi tətbiqi əllə gəzib düzgün ekranları yoxladığına ümid etmək deməkdir. Testlər olanda isə runner bir neçə saniyəyə sənə deyir ki, vacib saydığın davranış hələ də qüvvədədirmi. Martin Fowler "testlər kifayətdirmi" sualına məhz belə cavab verir: bug-lar production-a nadir hallarda çatır və sən kodu dəyişməkdən nadir hallarda çəkinirsən.
  • Davranışın spesifikasiyası. "adds up price times quantity" adı və onun nümunəsi xəbərsiz köhnələ bilməyən sənəddir: davranış dəyişsə, test uğursuz olur. Komandaya yeni gələn adam modulun nə vəd etdiyini test faylını oxuyaraq öyrənə bilər.
  • Əllə yoxlamadan sürətli cavab. Unit test millisaniyələrlə işləyir. Eyni qaydanı brauzerdə yoxlamaq bir dəqiqə çəkir və heç kim bunu hər dəyişiklikdən sonra hər kənar hal üçün etmir.
  • Dizayn haqqında siqnal. Saatı oxuyan, şəbəkəyə müraciət edən və qiyməti hesablayan, hamısını bir yerdə edən funksiyanı test etmək çətindir, təkrar istifadə etmək də. Test yazmaq bunu erkən göstərir.

Testlər nəyi vermir

Testlər yalnız yazdığın halların gözlədiyin kimi işlədiyini göstərir; kodda bug olmadığını sübut etmir. Səhv şeyi yoxlayan, ya da heç nəyi yoxlamayan test də yaxşı test qədər yaşıl görünür. Test yalnız assertion (və ya başqa nəsə) xəta atanda uğursuz olur, ona görə də heç bir assertion-ı olmayan test kod çökmədikcə keçir. Bu mövzunun qalan hissəsi də buna görə neçə test yazmaq haqqında yox, hansı testləri və harada yazmaq haqqındadır.

JuniorKonsepsiya

Unit, inteqrasiya və end-to-end testlər

Testlər sistemin nə qədərini bir anda işə saldıqlarına görə fərqlənir. Adətən üç səviyyədən danışılır:

  • kiçik bir məntiq parçasını tək halda yoxlayır: funksiyanı, hook-u, reducer-i. Ucuz asılılıqlar (təmiz köməkçi funksiya) real qalır; yavaş və ya idarəolunmaz olanlar (şəbəkə, saat) əvəz olunur.
  • bir neçə hissənin birlikdə işlədiyini yoxlayır: validasiyası və API client-i ilə birlikdə form, real uşaq komponentləri ilə birlikdə səhifə komponenti. Frontend-də bu, çox vaxt komponent ağacını simulyasiya olunmuş DOM-da render edib yalnız şəbəkəni əvəz etmək deməkdir.
  • real, build olunmuş tətbiqi real brauzerdə, real və ya realistik backend ilə işə salır və istifadəçi kimi davranır: səhifəni açır, yazır, klikləyir, ekranda nə çıxdığını yoxlayır. Ən çox işlədilən alətlər Playwright və Cypress-dir.
UnitİnteqrasiyaEnd-to-end
Adi işləmə müddətimillisaniyələronlarla-yüzlərlə mssaniyələr
Nəyi tuturməntiq xətaları, kənar hallaruyğun gəlməyən hissələr: props, sahə adları, çağırış sırasısınıq routing, build, konfiqurasiya, yalnız brauzerdə olan bug-lar
Bug-ın yerini göstərirdəqiqtəxminənnadir hallarda
Koddan kənar səbəbə görə düşürdemək olar ki, heç vaxtaz-aztez-tez: şəbəkə, test datası, vaxt

Hər səviyyənin qiyməti

Sürət qiymətin yalnız bir hissəsidir. Yuxarı səviyyəli testlər daha yavaşdır və onları qurmaq daha çətindir, amma əsas qiymət səs-küydür: end-to-end test test serveri ləng cavab verdiyi, lazımi qeyd bazaya yazılmadığı və ya animasiya hələ bitmədiyi üçün də düşə bilər. Kodda heç nə dəyişmədən bəzən düşən test adlanır və hər belə test komandanı qırmızı build-lərə məhəl qoymamağa öyrədir.

Aşağı səviyyəli testlərin zəifliyi isə əksinədir: onlar sürətli və dəqiqdir, amma məhsul sınıq olduğu halda hamısı keçə bilər. Hər unit ayrılıqda düzgün ola bilər, iki unit isə bir-biri ilə razılaşmaya bilər: məsələn, form { qty } göndərir, API client isə quantity oxuyur. Bunu yalnız ikisini birlikdə işə salan test görür.

Eyni dəyişiklik səviyyələrə müxtəlif cür təsir edir: daxili köməkçi funksiyanın adını dəyiş, onu çağıran unit testlər sınır, end-to-end testlər isə heç nə hiss etmir; checkout düyməsinin bağlantısını qır, bütün unit testlər yaşıl qalır. Yaxşı test dəstində səviyyələr qarışıq olur ki, hər növ səhvi ən azı bir test, mümkün qədər ucuz başa gələrək tutsun.

Bu adlar dəqiq deyil. "Unit"-in bir funksiya, yoxsa köməkçiləri ilə birlikdə bir modul olması komandadan komandaya dəyişir; Martin Fowler bunu "situasiyadan asılı şey" adlandırır. Vacib olan komandanın bu barədə razılaşmasıdır.

JuniorKonsepsiya

Arrange, act, assert

Yaxşı testlərin çoxu eyni üç addımdan ibarətdir. Bill Wake onları Arrange, Act, Assert (hazırla, icra et, yoxla) adlandırıb:

TypeScript
import { describe, expect, test } from "vitest";
import { applyCoupon } from "./coupon";

describe("applyCoupon", () => {
  test("takes 10% off with SAVE10", () => {
    // Arrange: giriş datası
    const order = { subtotal: 200, coupon: "SAVE10" };

    // Act: test olunan koda bir çağırış
    const result = applyCoupon(order);

    // Assert: çağıranın gördüyü nəticə
    expect(result.total).toBe(180);
  });

  test("rejects an expired coupon", () => {
    const order = { subtotal: 200, coupon: "SUMMER23" };
    expect(() => applyCoupon(order)).toThrow("Coupon has expired");
  });
});
  • Arrange vəziyyəti qurur: giriş datası, test datası, asılılıqların əvəzediciləri.
  • Act bir iş görür: funksiyanı çağırır, action göndərir, düyməni klikləyir.
  • Assert çağıranın görə bildiyi nəticəni yoxlayır: qaytarılan dəyəri, xətanı, ekrandakını, göndərilən sorğunu.

Behaviour-Driven Development eyni formanı Given, When, Then adları ilə işlədir (Daniel Terhorst-North və Chris Matts), Gerard Meszaros isə onu Four-Phase Test adlandırır və dördüncü addım, təmizləmə (teardown) əlavə edir. Martin Fowler bunları eyni şablon kimi təsvir edir.

Adlar

Testin adı bir davranışı ifadə edir ki, uğursuzluq pozulmuş vəd kimi oxunsun: applyCoupon > rejects an expired coupon. Kodu təsvir edən (calls validateDate) və ya heç nə deməyən (works, test 2) adlardan qaç. Ada "and" (və) lazım olursa, çox güman ki, bunlar iki ayrı testdir.

Testləri dürüst saxlayan vərdişlər

  • Uğursuzluğun bir səbəbi. Bir nəticəni təsvir edirlərsə, bir neçə expect normaldır: məsələn, eyni sifarişin cəmi və endirim sətri. On əlaqəsiz şeyi yoxlayan test on səbəbdən düşür və onun adı bunların hamısını təsvir edə bilmir.
  • Gözlənilən dəyərlər hazır yazılsın. toBe(200 - 200 * 0.1) və ya kodun özünün işlətdiyi köməkçi funksiyaya çağırış yox, toBe(180) yaz: cavabı kodla eyni yolla hesablayan test bug-ı da təkrarlayır.
  • Testdə məntiq olmasın. Test gövdəsindəki dövrlər və if-lər onu səhv ola bilən ikinci proqrama çevirir. Bir-birinə oxşar çoxlu hal üçün test.each ilə giriş cədvəlindən istifadə et.
  • Bir dəfə düşdüyünü gör. Yeni testə etibar etməzdən əvvəl kodu qəsdən sındır və ya testi düzəlişdən əvvəl işə sal və onun qırmızı olduğunu gör. Heç vaxt düşməmiş test, ola bilsin, heç nəyi yoxlamır.
MiddleKonsepsiya

Test piramidası və testing trophy

Layihədə hər səviyyədən neçə test olmalıdır? İki məşhur model bu suala fərqli cavab verir. Hər ikisi qanun yox, investisiyanın gəlirliliyi barədə fikirdir.

Test piramidası. Mike Cohn "Test Automation Pyramid"-i Succeeding with Agile (2009) kitabında təsvir edib, Martin Fowler-in bu barədə məqaləsi (2012) isə əsaslandırmanı verir: əsasda çoxlu sürətli unit test, ortada servis qatı üzərindən daha az test, zirvədə çox az UI testi, çünki UI üzərindən başdan-sona işləyən testlər "kövrək, yazılması baha və işləməsi uzun" olur. Ham Vocke-nin The Practical Test Pyramid məqaləsi (martinfowler.com, 2018) bunu iki qaydada ümumiləşdirir: müxtəlif detallıqda testlər yaz, səviyyə yüksəldikcə testlər azalmalıdır.

Testing trophy. Kent C. Dodds "Testing Trophy"-ni JavaScript tətbiqləri üçün çəkib (2018): ən aşağıda statik analiz, sonra unit, ən böyük hissə kimi inteqrasiya, ən yuxarıda end-to-end. Onun fikrincə, inteqrasiya testləri "əminlik ilə sürət/xərc arasındakı kompromisdə əla balans yaradır", ona görə səyin çoxu (hamısı yox) ora getməlidir. Bunun arxasında onun prinsipi dayanır, bu, həm də Testing Library-nin əsas prinsipidir: "Testlər proqramın necə istifadə olunduğuna nə qədər çox bənzəsə, sənə bir o qədər çox əminlik verə bilər."

Text
                pyramid (Cohn)     trophy (Dodds)
fewest          UI / E2E           end-to-end
                service            integration (most effort)
most            unit               unit
underneath      -                  static: types, lint

Statik analiz təməldir. Dodds onu ona görə əlavə edib ki, JavaScript-də statik analiz öz-özünə mövcud deyil; o, "kodu yazdığın anda yazı və tip xətalarını tutur". Strict TypeScript və ESLint heç bir test işləməmişdən əvvəl hər sətri demək olar ki, pulsuz yoxlayır. Testləri tip yoxlayıcısının sübut etdiyinə (cartTotal-ın ədəd qaytardığına) xərcləmə; tiplərin görə bilmədiyinə (onun düzgün ədəd qaytardığına) xərclə.

Modellərin razılaşdığı yerlər

Fowler qeyd edib (2021) ki, mübahisənin çox hissəsi "unit test"-in nə demək olduğu üstündədir. Komponenti real uşaqları ilə render edən test bəziləri üçün sociable unit testdir (Jay Fields-in termini; asılılıqları double-larla əvəz edən solitary testin əksi), digərləri üçün isə inteqrasiya testi. Hər iki model razılaşır ki, testlərin çoxu sürətli və deterministik olmalıdır, end-to-end testlər ən baha növdür və vacib istifadəçi ssenarilərinə aiddir, test isə öz yerini yazılmasına, işləməsinə və saxlanmasına sərf olunan hər dəqiqəyə düşən əminliklə qazanır.

React tətbiqi üçün bu, belə deməkdir: komponentləri real uşaqları ilə render edib yalnız şəbəkəni saxtalaşdıran çoxlu sürətli test, ağır məntiq (parsing, qiymət, tarixlər) üçün unit testlər və heç vaxt sınmamalı olan axınlar üçün bir neçə end-to-end test.

MiddleTipik səhvlər

İmplementasiya detallarını test etmək

Kent C. Dodds implementasiya detallarını belə tərif edir: "kodunun istifadəçilərinin adətən istifadə etmədiyi, görmədiyi, hətta bilmədiyi şeylər". Funksiyanın istifadəçiləri onu çağıranlardır. Komponentin isə iki istifadəçisi var: onu görüb klikləyən son istifadəçi və onu props ilə render edən developer. Bundan başqa hər hansı şeydən asılı olan testin iki problemi var və Dodds onları belə adlandırır:

  • False negative (yalançı mənfi): kod hələ də işlədiyi halda test refaktorinqdən sonra düşür. İnsanlar yeni daxili quruluşu testə köçürərək "testi düzəltməyə" alışır və qırmızı nəticəyə etibar etməyi dayandırır.
  • False positive (yalançı müsbət): kod sınıq olduğu halda test keçir, çünki o, nəticəni yox, daxili addımları yoxlayır.
TypeScript
// ✗ daxili state-i oxuyur
test("stores the item", () => {
  const cart = createCart();
  cart.add({ id: "tea", price: 4 });
  expect(cart._items).toEqual([{ id: "tea", price: 4, quantity: 1 }]);
});

// ✓ public API-dən istifadə edir
test("counts a repeated item in the total", () => {
  const cart = createCart();
  cart.add({ id: "tea", price: 4 });
  cart.add({ id: "tea", price: 4 });
  expect(cart.count()).toBe(2);
  expect(cart.total()).toBe(8);
});

_items id açarı ilə saxlanan Map-ə çevrilsə, çağıranlar üçün heç nə dəyişməsə də, birinci test sınır. total() sınıq olanda isə o, keçməyə davam edir, çünki onu heç çağırmır. İkinci test daxili hissə yenidən yazılandan sonra da keçir və məhz çağıranın səhv rəqəm görəcəyi anda düşür.

Vitest bələdçisindən praktik yoxlama: kimsə daxili hissəni yenidən yazsa və nəticə eyni qalsa, bu test sınmalıdırmı? Sınacaqsa, o, implementasiya detalını yoxlayır.

Nəyə diqqət etməli

  • private sahələrə, daxili state-ə və ya nəyinsə neçə dəfə render olunduğuna dair assertion-lar;
  • kodun daxildə çağırdığı köməkçi funksiyanı yalnız çağırılıb-çağırılmadığını yoxlamaq üçün izləmək (spy);
  • eyni feature-un öz modullarını mock etmək, nəticədə test nəticəni yox, bağlantıları təsvir edir;
  • hər refaktorinqlə eyni commit-də dəyişən test faylı.

Private köməkçi funksiyanın ayrıca testlərə ehtiyacı varmış kimi görünürsə, Ham Vocke-nin məsləhətinə görə, çox güman ki, modul həddindən artıq çox iş görür: köməkçini öz public müqaviləsi olan modula çıxar və onu test et. React komponentləri üçün qayda belə səslənir: istifadəçi kimi qarşılıqlı əlaqəyə gir və state-i və ya uşaqların props-unu yox, ekranda olanı yoxla. Testing Library məhz bu ideya üzərində qurulub.

Amma hər nəticə qaytarılan dəyər deyil. onSave-i form dəyərləri ilə çağırmaq, analitika event-i göndərmək və ya storage-ə yazmaq çağıranların güvəndiyi şeydir və bunu test double ilə yoxlamaq davranışı test etməkdir. Sual budur: bu çağırış müqavilənin bir hissəsidir, yoxsa sadəcə nəticəyə çatmağın yollarından biri?

MiddleKonsepsiya

Nəyi test etməli, nəyi buraxmalı

Hər test yazılmağa, işləməyə və yenilənməyə vaxt aparır. Bu vaxtı bug-ların ehtimalı yüksək və baha başa gəldiyi yerlərə xərclə.

Test etməyə dəyər

  • Budaqları olan məntiq: qiymətlər, endirimlər, icazələr, parsing, formatlama, validasiya qaydaları, reducer-lər, state maşınları.
  • Sərhədlər: boş siyahı, sıfır, mənfi ədədlər, maksimal uzunluq, ayın son günü, çatışmayan optional sahə.
  • Xəta yolları: yanlış giriş, reject olunmuş sorğu, timeout. Bunları heç kim əllə yoxlamır.
  • Hissələr arasındakı müqavilələr: komponentin API client-ə göndərdiyi data forması, vidjetin göndərdiyi event-lər, hook-un qaytardığı dəyər.
  • Əvvəllər sınmış hər şey. Bug kodun harada kövrək olduğunu göstərir, onun reqressiya testi isə onun geri qayıtmasının qarşısını alır.

Adətən ayrıca testə dəyməz

  • Üçüncü tərəf kodu. React-in yenidən render etdiyini, Array.prototype.sort-un sıraladığını və ya tarix kitabxanasının ISO sətirlərini parse etdiyini test etmə: bunu onların öz test dəstləri edir. Onlardan sənin necə istifadə etdiyini test et: cədvəlinin vəd etdiyi sıranı, funksiyanın verilmiş giriş üçün qaytardığı tarixi.
  • Trivial kod. Sahəni qaytaran getter, props-u sadəcə ötürən komponent, sabit. Ham Vocke-nin qaydası qısadır: "trivial kodu test etmirsən". Bu kod onu işlədən kodun testlərində onsuz da işləyir.
  • Tip yoxlayıcısının onsuz da sübut etdiyi şeylər. Strict TypeScript arqumenti çatışmayan çağırışı qəbul etmirsə, həmin çağırışı yoxlayan test yalnız kompilyatoru yenidən test edir.
  • Stillər və dəqiq markup. Class adları, rənglər və boşluqlar tez-tez dəyişir və davranış haqqında az şey deyir. jsdom kimi simulyasiya olunmuş DOM-lar ümumiyyətlə layout hesablamır (bunu onun README-si də deyir), ona görə elementin ekranda görünüb-görünmədiyini və ya başqası ilə örtülüb-örtülmədiyini bilə bilmir. Davranışı test et (deaktiv düymə, xəta mesajı), görünüşü isə real brauzerdəki screenshot testlərinə burax.
  • Eyni qayda hər səviyyədə. Unit testlər bütün endirim qaydalarını əhatə edirsə, end-to-end checkout testinə on iki yox, bir kupon kifayətdir. Vocke-nin məsləhəti testləri piramidada bacardığın qədər aşağı salmaqdır.

Sürətli filtr

Test yazmazdan əvvəl iki sual ver. Bu davranış sınsa, istifadəçi və ya başqa developer bunu hiss edərmi? Bu test mənə bunu artıq olan testlərdən daha tez və ya daha dəqiq deyərmi? Hər iki cavab "yox"-dursa, test, çox güman ki, gətirdiyindən çox baha başa gəlir.

Əks səhv uğurlu ssenari (happy path) işlədiyi üçün xəta yolunu buraxmaqdır. Ekranda heç bir xəta mesajı göstərməyən reject olunmuş sorğu real bug-dır və onu yalnız test, ya da istifadəçi tapacaq.

MiddleKonsepsiya

Code coverage: nəyi ölçür və nəyi ölçmür

Coverage aləti testlər işlədiyi müddətdə kodunun hansı hissələrinin işlədiyini qeyd edir. Vitest onu vitest run --coverage ilə toplayır (standart olaraq v8 provayderi ilə, ya da istanbul ilə) və hər fayl üçün dörd rəqəm göstərir:

  • statements və lines: onların neçəsi ən azı bir dəfə icra olunub;
  • functions: neçə funksiya ən azı bir dəfə çağırılıb;
  • branches: if/else, ? :, &&, ||, ?? və switch üzərindən keçən yolların (budaqların) neçəsinə girilib.

Hesabatdan ən çox xəritə kimi faydalanırsan. Qırmızı sətirlər heç bir testin işə salmadığı koddur, çox vaxt da heç kimin ağlına gəlməyən xəta yoludur.

Coverage nəyi deyə bilmir

Coverage nəyin yoxlandığını yox, nəyin işlədiyini ölçür:

TypeScript
function shippingCost(total: number, country: string) {
  if (country !== "AZ") return 15;
  return total >= 50 ? 0 : 5;
}

test("shipping", () => {
  shippingCost(10, "AZ");
  shippingCost(60, "AZ");
  shippingCost(60, "DE");
});

Bu test sətirlərin, funksiyaların və budaqların 100%-ni əhatə edir, amma heç nə yoxlamır: bütün qaytarılan dəyərlər səhv olsa da, keçəcək. Martin Fowler bunun ifrat halını "AssertionFreeTesting" adlandırır. Yaxşı assertion-lar olsa belə, 100% branch coverage o demək deyil ki, şərtlərin bütün kombinasiyaları yoxlanılıb, sərhəd (cəmin düz 50 olması) yoxlanılıb və ya kod məhsula lazım olanı edir.

Fowler-in fikrincə, coverage "kod bazasının test olunmamış hissələrini tapmaq üçün faydalı alətdir", amma "testlərinin nə qədər yaxşı olduğunu göstərən rəqəm kimi az işə yarayır". Aşağı rəqəmlər, "təxminən yarıdan az", problem əlamətidir; yüksək rəqəmlər isə mütləq nəsə demək deyil. 100%-ə çox yaxın rəqəm onda metrikanı razı salmaq üçün yazılmış testlərə dair şübhə yaradardı. Kent C. Dodds da razıdır: təxminən 70%-dən sonra fayda azalır (bu rəqəmi uydurduğunu özü etiraf edir), tətbiq üçün 100% tələb etmək isə "çox pis ideyadır".

CI-da coverage

Vitest konfiqurasiyasındakı coverage.thresholds sətirlər, funksiyalar, budaqlar və statement-lər üçün minimal faizləri təyin edir; nəticə onlardan aşağı olanda run xəta ilə bitir və CI job-u düşür. Alt hədd kimi işlədiləndə threshold test olunmamış kod əlavə olunanda coverage-in səssizcə düşməsinin qarşısını alır. Məqsəd kimi işlədiləndə isə yuxarıdakı kimi testlərə yol açır. Fowler fərqi Brian Marick-in sözləri ilə göstərir: "I expect a high level of coverage. Sometimes managers require one. There's a subtle difference." (Mən yüksək coverage gözləyirəm. Bəzən menecerlər onu tələb edir. Fərq incədir.)

Review zamanı dəyişən sətirlərə bax: yeni budaq əhatə olunubmu və bu budaq səhv dəyər qaytarsa, düşəcək assertion varmı?

SeniorKonsepsiya

CI-da və code review-da testlər

Testlər kod bazasını yalnız o halda qoruyur ki, hər dəyişiklikdə işə salınsınlar və onlar düşən halda heç nə merge olunmasın. Pull request üçün pipeline əvvəlcə ən ucuz yoxlamaları işə salır ki, yazı xətası uzun brauzer run-ından sonra yox, bir neçə saniyəyə üzə çıxsın:

Shell
npx tsc --noEmit
npx eslint .
npx vitest run --coverage
npx playwright test

Developer-in kompüterində vitest watch rejimində başlayır, CI-da isə (process.env.CI təyin olunanda) və ya interaktiv olmayan terminalda bir dəfə işləyir. Review üçün CI-ın iki standart davranışı vacibdir. Vitest CI-da snapshot yazmır: çatışmayan, dəyişmiş və ya köhnəlmiş snapshot qeyd olunmaq əvəzinə run-ı uğursuz edir, ona görə snapshot yalnız kimsə onu lokal yeniləyib diff-i commit edəndə dəyişir. allowOnly isə CI-da söndürülüb, ona görə unudulmuş test.only qalan bütün testləri səssizcə ötürmək əvəzinə test dəstini uğursuz edir.

Test dəstini sürətli və etibarlı saxla

  • Vaxt büdcəsi. Fowler Kent Beck-in təcrübi qaydasını xatırladır: commit zamanı işləyən test dəsti on dəqiqədən çox çəkməməlidir. Daha yavaş dəst lokal olaraq daha az işə salınır və onun cavabı developer artıq başqa işə keçəndən sonra gəlir.
  • Determinizm. Kod dəyişmədən bəzən düşən test testin olmamasından da pisdir: insanlar pipeline-ı yaşıl olana qədər yenidən işə salır, növbəti real xəta da eyni münasibətlə qarşılanır. Fowler qeyri-deterministik testləri "faydasız" və "sürətlə yayılan infeksiya" adlandırır və onları avtomatik retry-ların arxasında gizlətmək yox, karantinə almaq və tez düzəltmək məsləhətini verir.
  • Bir əmr. Developer-lər CI-ın işə saldığını eyni konfiqurasiya ilə lokal olaraq da işə sala bilməlidir.

Pull request-də testlərin review-u

Testləri koddan əvvəl oxu: onlar müəllifin dəyişiklikdən nə gözlədiyini deyir.

  • Yeni davranış üçün onu göstərə bilən ən aşağı səviyyədə test varmı?
  • Dəyişiklik olmasa, test düşərdimi? Bu, aydın deyilsə, branch-a keç (checkout), düzəlişi geri qaytar və testi işə sal.
  • Assertion-lar nəticələri (qaytarılan dəyərlər, ekrandakı mətn, göndərilən sorğular), yoxsa daxili hissələri yoxlayır?
  • Mövcud gözlənilən dəyərlər dəyişibmi? Yeni gözlənilən dəyərlər tələb edən refaktorinq refaktorinq deyil; hansı davranışın dəyişdiyini və bunun qəsdən olub-olmadığını soruş.
  • Hər yenilənmiş snapshot dəyişikliklə izah olunurmu?

Testlər dizayn siqnalı kimi

Komponenti test etmək üçün ondan çox mock lazımdırsa, problem testdə yox, dizayndadır: komponent həddindən artıq çox iş görür və ya çox sayda modula birbaşa müraciət edir. Yazılması əziyyətli olan test çox vaxt kodun dəyişdirilməsinin də əziyyətli olacağına dair ilk xəbərdarlıqdır.

SeniorNümunə

Bug hesabatı: əvvəlcə reqressiya testi, düzgün səviyyədə

Bug hesabatı test əlavə etmək üçün ən yaxşı andır: kodun orada kövrək olduğunu bilirsən və əlində konkret uğursuz hal var. Martin Fowler yüksək səviyyəli testin aşkarladığı bug üçün belə məsləhət verir: düzəltməzdən əvvəl onu unit testlə təkrarla. Ham Vocke-nin variantı: yüksək səviyyəli test xəta tapıbsa və heç bir aşağı səviyyəli test düşmürsə, aşağı səviyyəli test yaz.

Hesabat: "Səbətin cəmi düz 50 olanda pulsuz çatdırılma tətbiq olunmur."

  1. Bug-ı onu göstərə bilən ən aşağı səviyyədə təkrarla. Qayda təmiz funksiya olan shippingCost-dadır, ona görə bunu unit test edə bilər:
TypeScript
test("ships free at exactly the threshold", () => {
  expect(shippingCost(50, "AZ")).toBe(0);
});
  1. Testin hesabatdakı səbəbə görə düşdüyünü gör: 0 əvəzinə 5 alır. Test keçirsə, bug başqa yerdədir və test səni indicə səhv düzəlişdən xilas edib.
  2. Kodu düzəlt (total > 50 total >= 50 olur), testin keçdiyini gör, sonra bütün test dəstini işə sal: başqa kod köhnə qaydaya güvənmiş ola bilər.
  3. Testi saxla. O, düz 50-nin pulsuz çatdırıldığı qərarını sənədləşdirir və kimsə bug-ı geri qaytarsa, düşür.

Səviyyəni seçmək

Bug-ı təkrarlayan ən aşağı səviyyə adətən doğru seçimdir, amma hər bug bir unit-in içində yaşamır:

Bug haradaNə yazNümunə
bir funksiya və ya modulun içindəki qaydadaunit testyuvarlaqlaşdırma, tarix sərhədi, reducer halı
hissələr arasındakı müqavilədəinteqrasiya testiform qty göndərir, API client quantity oxuyur
yalnız işləyən tətbiqin göstərdiyi şeydəend-to-end testdeploy-dan sonra 404 verən route, heç vaxt göndərilməyən cookie

Bug-ı istifadəçi və ya end-to-end test tapıbsa və onu aşağı səviyyəli test də təkrarlaya bilirsə, aşağı səviyyəli testə üstünlük ver: o, daha sürətlidir, səbəbi göstərir və flaky olmur. End-to-end testi aşağı səviyyələrin göstərə bilmədiyi bug-lar üçün saxla.

Test nə vaxt dəyməz

Məntiq yenidən sına bildiyi yerdə reqressiya testi ucuz sığortadır. Düzəliş kodda yox, datada olanda (bazadakı səhv qeyd), bug mətndəki hərf səhvi olanda və ya onu təkrarlayan yeganə test o qədər yavaş və ya etibarsız olanda ki, komanda onu tezliklə ötürməyə başlayacaq, onun faydası azdır. Belə halda bunu pull request-də yaz ki, review edən boşluğun qəsdən buraxıldığını bilsin.

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

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

30 saniyəlik cavab. "Testlər mənə kodu dəyişməyə əminlik verir və onun nə etməli olduğunu təsvir edir. Səviyyəni nəyin sına biləcəyinə görə seçirəm: məntiq üçün unit testlər, hissələrin birlikdə işləməsi üçün inteqrasiya testləri (React tətbiqində bu, komponentləri real uşaqları ilə render edib yalnız şəbəkəni saxtalaşdırmaq deməkdir) və heç vaxt sınmamalı olan ssenarilər üçün real brauzerdə bir neçə end-to-end test. Yuxarı səviyyələr hər test üçün daha çox əminlik verir, amma daha yavaş, daha flaky və debug etmək üçün daha çətindir. Davranışı implementasiya detalları üzərindən yox, public API üzərindən test edirəm ki, refaktorinq testləri sındırmasın. Coverage mənə nəyin test olunmadığını göstərir, testlərin yaxşı olduğunu isə demir."

Gözlənilən suallar

  • Piramida, yoxsa trophy? Hər ikisini və müəlliflərini adlandır (Mike Cohn, Martin Fowler-in izahı ilə; Kent C. Dodds), fikir ayrılığının çoxunun "unit"-in nə olduğu barədə olduğunu izah et və bu tip tətbiq üçün nəyi seçəcəyini və niyə seçəcəyini de.
  • İmplementasiya detalı nədir? Çağıranların görə və istifadə edə bilmədiyi şey. False negative və false positive arqumentini nümunə ilə göstər, məsələn, komponentin state-ini oxuyan test.
  • 100% coverage yaxşı məqsəddirmi? Yox: coverage nəyin yoxlandığını yox, nəyin işlədiyini göstərir. Ondan test olunmamış kodu tapmaq üçün və CI-da alt hədd kimi istifadə et.
  • Bug hesabatı ilə necə işləyirsən? Bug-ı onu göstərən ən aşağı səviyyədə uğursuz testlə təkrarla, kodu düzəlt, testi saxla.
  • Nəyi test etməzdin? Üçüncü tərəf kodunu, trivial kodu, tip yoxlayıcısının sübut etdiyini, stil detallarını.
  • End-to-end testlər niyə flaky olur və bununla nə edirsən? Hərəkətli hissələr çoxdur: şəbəkə, data, vaxt, brauzer. Onları az saxla, deterministik et, flaky olanları retry etmək əvəzinə karantinə al və düzəlt.

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

  • Səviyyələri alətə görə müəyyən etmək ("Vitest unit-dir, Playwright E2E"). Bütöv formu real API client-i və saxta şəbəkə ilə render edən Vitest testi inteqrasiya testidir.
  • Piramidaya və ya trophy-yə xərclərin modeli kimi yox, qayda kimi baxmaq.
  • Yalnız mock-un çağırıldığını yoxlayan testi, həmin çağırış müqavilənin hissəsi olmadığı halda, "davranışın testi" adlandırmaq.
  • "Bizdə 90% coverage var" sözünü kodun yaxşı test olunduğuna sübut kimi təqdim etmək.

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

Test dəstindən işlətmə xərcləri olan bir şey kimi danış: CI nə qədər çəkir, hansı testlər flaky-dir və onları kim düzəldir, hansı testlər hər refaktorinqdə sınır, hansı bug-lar production-a çatıb və onları hansı səviyyə tutmalı idi. Testləri riskə görə yerləşdir: ödənişlər və giriş end-to-end testlərlə əhatə olunur, tarix köməkçisi unit testlər cədvəli alır, statik marketinq səhifəsi isə demək olar ki, heç nə. Test etmək çətin olan modula daha çox mock üçün səbəb kimi yox, dizayn problemi kimi bax.

JuniorYoxlama siyahısı

Testləri review edərkən nəyi yoxlamalı

Yazmadığın testləri — komanda yoldaşının pull request-ində, kitabxananın nümunəsində və ya AI assistentin təklifində — review edəndə bu siyahıdan istifadə et. Yaşıl CI run-ında zəif test də güclü test kimi görünür; bu review-u ötürsən, "test olunmuş" bug-lar və onlarla testi sındıran refaktorinqlər alırsan.

  • Davranış sınsa, test düşərdimi? Kodu qəsdən sındır və ya düzəlişi geri qaytar və testi işə sal. Yaşıl qalan, heç bir expect-i olmayan və ya gözlənilən dəyəri kodla eyni məntiqlə hesablayan test heç nəyi yoxlamır; Vitest-də expect.requireAssertions seçimi assertion-sız testləri uğursuz edir.
  • Test çağıranın görə bildiyi şeyi yoxlayırmı? Qaytarılan dəyərlər, atılan xətalar, ekrandakı mətn və göndərilən sorğular refaktorinqdən sağ çıxır. Private sahələrə, daxili state-ə və ya daxili köməkçi funksiyaların çağırışlarına dair assertion-lar hər yenidən yazılmada sınır və yenə də real bug-ları buraxır.
  • Test davranışı göstərə bilən ən aşağı səviyyədədirmi? Qaydaların yeri sürətli unit testlər, bağlantıların yeri inteqrasiya testləridir. Bir validasiya qaydası üçün end-to-end test yavaş və flaky olur, bütün qonşuları mock olunmuş unit test isə iki modulun razılaşmadığı sahə adını tuta bilmir.
  • Hər ad bir davranışı ifadə edirmi? describe və test adlarını cümlə kimi oxu: "applyCoupon > rejects an expired coupon" nəyin sındığını deyir; "works" və ya "and" ilə birləşdirilmiş ad bir neçə halı gizlədir.
  • Yalnız uğurlu ssenari yox, kənar hallar və xəta yolları da test olunubmu? Boş girişə, sıfıra, "düz 50" kimi sərhədlərə və reject olunmuş sorğulara bax. Coverage hesabatı heç bir testin girmədiyi budaqları göstərir.
  • Test özündən kənar nədənsə asılıdırmı? Başqa testlərin qoyub getdiyi state, real saat, təsadüfi dəyərlər və ya şəbəkə testin keçib-keçməməsini təsadüfdən asılı edir. Yoxlamaq üçün faylı tək və təsadüfi sıra ilə işə sal (vitest run cart.test.ts --sequence.shuffle).
  • Dəyişmiş hər gözlənilən dəyər və snapshot qəsdəndirmi? Hansı davranışın niyə dəyişdiyini soruş. Heç kimin oxumadığı yenilənmiş snapshot qəbul edilmiş bug-dır.

Ö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