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

Testləşdirmə

Unit testlər və test double-lar

Vitest ilə unit testlər yazmaq: test və describe, bərabərlik matcher-ləri, xətalar və promise-lər, təmiz funksiyalar və ötürülən asılılıqlarla kodu test oluna bilən etmək, test double-ların beş növü, vi.fn, vi.spyOn və onların bərpası, testlərin təcrid olunması, həddindən artıq mock və snapshot testlərin hüdudları.

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.

JuniorKonsepsiya

Vitest ilə ilk unit test

kodun bir hissəsini seçdiyin girişlərlə çağırır və çıxışı yoxlayır. Test etmək üçün ən asan kod təmiz funksiyadır (pure function): onun nəticəsi yalnız arqumentlərindən asılıdır və o, özündən kənarda heç nəyi dəyişmir. Nəyisə hazırlamaq, təmizləmək və ya gözləmək lazım deyil: çağırırsan və müqayisə edirsən.

TypeScript
// price.ts
export function formatPrice(cents: number, currency = "AZN"): string {
  if (!Number.isInteger(cents)) throw new TypeError("cents must be an integer");
  return `${(cents / 100).toFixed(2)} ${currency}`;
}
TypeScript
// price.test.ts
import { describe, expect, it, test } from "vitest";
import { formatPrice } from "./price";

describe("formatPrice", () => {
  it("formats cents with two decimals", () => {
    expect(formatPrice(1999)).toBe("19.99 AZN");
  });

  it("uses the currency it is given", () => {
    expect(formatPrice(250, "EUR")).toBe("2.50 EUR");
  });

  test.each([
    [0, "0.00 AZN"],
    [5, "0.05 AZN"],
    [100000, "1000.00 AZN"],
  ])("formats %i as %s", (cents, expected) => {
    expect(formatPrice(cents)).toBe(expected);
  });
});
  • test(name, fn) testi təyin edir. it eyni funksiyanın başqa adıdır: onunla it("formats…") ingiliscə cümlə kimi oxunur.
  • describe(name, fn) testləri qruplaşdırır; uğursuzluq formatPrice > formats cents with two decimals kimi göstərilir.
  • expect(value) assertion-ı başladır, toBe kimi matcher isə onu tamamlayır. Uğursuz matcher xəta atır və test uğursuz olur. .not istənilən matcher-i tərsinə çevirir: expect(x).not.toBe(0).
  • test.each eyni testi cədvəlin hər sətri üçün bir dəfə işə salır; addakı %i və %s sətrin dəyərləri ilə əvəz olunur.

Vitest bu funksiyaları default olaraq qlobal etmir (globals: false), ona görə onları "vitest"-dən import edirsən. Testlər default olaraq Node.js mühitində işləyir və bu, təmiz məntiq üçün uyğundur; komponent testləri environment seçimini jsdom və ya happy-dom edir. İşləyərkən faylları izləmək üçün npx vitest, bir dəfəlik run üçün npx vitest run əmrini işə sal.

Halları seçmək

Hər test funksiyanın müqaviləsinin bir nümunəsidir: adi giriş, sərhədlər (sıfır, real ola biləcək ən böyük dəyər) və yanlış giriş. Hər testi göstərdiyi qaydaya görə adlandır. Gözlənilən dəyərləri literal kimi yaz ("19.99 AZN"), kodun istifadə etdiyi düsturla yenidən hesablama: hesablamanı təkrarlayan test onun bug-larını da təkrarlayır.

Funksiya saatı oxuduğu, şəbəkəyə müraciət etdiyi və ya render olunmuş komponent tələb etdiyi üçün onu bu yolla test etmək çətindirsə, bu, adətən onu bölməyin vaxtı olduğuna işarədir: qaydaları saxlayan təmiz nüvə və yan təsirləri (side effect) icra edən nazik qat.

JuniorKonsepsiya

toBe, toEqual və toStrictEqual

toBe dəyərləri Object.is ilə müqayisə edir: bu, === ilə eynidir, yalnız NaN NaN-a bərabər sayılır, 0 isə -0-dan fərqlənir. Sətirlər, ədədlər və boolean-lar üçün elə istədiyin budur. Obyektlər və massivlər üçün isə o, eyniliyi (identity) yoxlayır, ona görə məzmunu eyni olan iki obyekt toBe ilə bərabər deyil:

TypeScript
const a = { id: 1, tags: ["new"] };
const b = { id: 1, tags: ["new"] };

expect(a).toBe(a);
expect(a).not.toBe(b);
expect(a).toEqual(b);

toEqual rekursiv müqayisə edir: eyni açarlar və ən dərinə qədər bərabər dəyərlər. Vitest sənədləri onun toStrictEqual-dan daha yumşaq olduğu üç yeri sadalayır:

  • dəyəri undefined olan açarlar nəzərə alınmır: { a: undefined, b: 2 } və { b: 2 } bərabər sayılır;
  • massivdəki boşluqlar yoxlanmır: [, 1] və [undefined, 1] bərabər sayılır;
  • obyektin tipi yoxlanmır: class-ın instance-ı eyni sahələri olan adi obyektə bərabər sayılır.
TypeScript
class Money {
  amount: number;
  currency: string;
  constructor(amount: number, currency: string) {
    this.amount = amount;
    this.currency = currency;
  }
}

const price = new Money(5, "AZN");
expect(price).toEqual({ amount: 5, currency: "AZN" });
expect(price).not.toStrictEqual({ amount: 5, currency: "AZN" });
expect({ amount: 5, note: undefined }).toEqual({ amount: 5 });
expect({ amount: 5, note: undefined }).not.toStrictEqual({ amount: 5 });

Dəqiq forma müqavilənin hissəsidirsə, toStrictEqual yaz: reducer-in növbəti state-i, API-yə göndərilən payload, class-ın instance-ı olmalı olan dəyər. "Eyni data" kifayət edəndə toEqual yaz.

Gündəlik digər matcher-lər

  • toMatchObject(subset): obyektdə ən azı bu xüsusiyyətlər var, rekursiv yoxlanılır; əlavə xüsusiyyətlərə icazə verilir. Bütün sahələri sadalamadan "yeni sifarişin statusu pending-dir" demək üçün yaxşıdır.
  • toContain(item): massivdə element və ya sətirdə alt sətir. toHaveLength(n) .length-i yoxlayır.
  • toBeCloseTo(n, digits?): kəsr ədədli (floating-point) nəticələr üçün. 0.1 + 0.2 əslində 0.30000000000000004-dür, ona görə toBe(0.3) uğursuz olur, toBeCloseTo(0.3) isə keçir; başqa ədəd ötürməsən, nöqtədən sonra 2 rəqəm yoxlanılır.
  • toBeNull(), toBeUndefined(), toBeTruthy(), toBeFalsy(). Ən konkret matcher-i seç: dəyər boolean true olmalıdırsa, toBe(true) yaz, çünki toBeTruthy() 1-i və "no"-nu da qəbul edir.
JuniorKonsepsiya

Xətaları və promise-ləri test etmək

Xətalar

toThrow funksiyanı çağırır və onun xəta atdığını yoxlayır. Ona funksiyanın özünü ötür, çağırışın nəticəsini yox:

TypeScript
expect(() => formatPrice(1.5)).toThrow("cents must be an integer");
expect(() => formatPrice(1.5)).toThrow(/integer/);

// ✗ formatPrice arqument hesablanarkən, expect işə düşməmiş xəta atır
expect(formatPrice(1.5)).toThrow();

Son sətirdə JavaScript expect-in arqumentini hesablamaq üçün formatPrice(1.5)-i çağırır, ona görə xəta toThrow onu tuta bilməmiş çölə çıxır və test həmin xəta ilə uğursuz olur. Vitest sənədləri bunu açıq deyir: kodu funksiyaya bükməlisən, əks halda xəta tutulmayacaq. Sətir arqumenti mesajın bir hissəsini (substring), regular expression isə şablonu yoxlayır. Yalnız "nəsə" atıldığını yox, mesajı da yoxla: TypeError: x is not a function atan hərf səhvi də arqumentsiz toThrow() yoxlamasından keçir.

Promise-lər

Test funksiyası async ola bilər; Vitest onun qaytardığı promise-i gözləyir. Ya dəyəri await et və adi matcher-lərdən istifadə et, ya da .resolves və .rejects yaz:

TypeScript
const api = {
  getUser: async (id: number) => (id === 1 ? { id, name: "Leyla" } : null),
};

test("loads a user", async () => {
  const user = await loadUser(1, api);
  expect(user.name).toBe("Leyla");
});

test("rejects an unknown id", async () => {
  await expect(loadUser(999, api)).rejects.toThrow("User 999 not found");
});

.resolves və .rejects matcher-i promise-ə çevirir, ona görə sətir await olunmalıdır. Vitest 5.0-dan bəri belə assertion await olunmasa, test uğursuz olur; ondan əvvəl Vitest onu testin sonunda gözləyirdi və yalnız xəbərdarlıq çap edirdi. Ümumi qayda istənilən test runner-dən köhnədir: heç kimin await etmədiyi və ya qaytarmadığı promise testin hissəsi deyil, onun uğursuzluğu da testin uğursuzluğu sayılmır.

Nəticəni callback vasitəsilə bildirən kod üçün testin əvvəlində expect.assertions(n) düz n assertion-ın işlədiyini, expect.hasAssertions() isə ən azı birinin işlədiyini yoxlayır. Hər ikisi yeganə expect-i heç vaxt çağırılmayan callback-də qalan testi tutur.

Kiçik api obyekti real client-in yerinə əllə yazılmış əvəzedicidir: test double-ın ən sadə növü və loadUser-in client-i import etmək əvəzinə parametr kimi qəbul etməsinin səbəbi.

MiddleNümunə

Kodu test oluna bilən etmək: təmiz funksiyalar və ötürülən asılılıqlar

Komponentin içində yazılmış məntiqi yalnız komponenti render edərək test etmək olar. Eyni məntiq təmiz funksiya kimi hər hal üçün bir sətirlə test olunur. Tipik refaktorinq:

TSX
// əvvəl: qaydalar komponentin içindədir
function CheckoutSummary({ items, coupon }: Props) {
  let subtotal = 0;
  for (const item of items) subtotal += item.price * item.quantity;
  const discount = coupon === "SAVE10" && subtotal >= 50 ? subtotal * 0.1 : 0;
  const shipping = subtotal - discount >= 100 ? 0 : 5;
  return <Summary subtotal={subtotal} discount={discount} shipping={shipping} />;
}
TypeScript
// sonra: qaydaları təmiz funksiya saxlayır
export function summarize(items: Item[], coupon?: string) {
  const subtotal = items.reduce((sum, i) => sum + i.price * i.quantity, 0);
  const discount = coupon === "SAVE10" && subtotal >= 50 ? subtotal * 0.1 : 0;
  const shipping = subtotal - discount >= 100 ? 0 : 5;
  return { subtotal, discount, shipping, total: subtotal - discount + shipping };
}

İndi komponent summarize(items, coupon)-u çağırır və nəticəni render edir. Hər qayda və qaydaların bir-birinə təsiri (endirim pulsuz çatdırılma həddinə sayılırmı?) sürətli unit test alır, bir-iki komponent testi isə rəqəmlərin ekrana çatdığını yoxlayır.

Yan təsirlər kənarda, asılılıqlar parametr kimi

Hər şey təmiz ola bilməz: kod saatı oxuyur, şəbəkəyə müraciət edir, storage-ə yazır. Bu çağırışları kənarda saxla və onlara içəridən əl uzatmaq əvəzinə parametr kimi ötür:

TypeScript
type Deps = {
  now: () => Date;
  post: (order: Order) => Promise<void>;
};

export async function placeOrder(cart: Cart, { now, post }: Deps) {
  if (cart.items.length === 0) throw new Error("Cart is empty");
  await post({ items: cart.items, placedAt: now().toISOString() });
}

Tətbiq placeOrder(cart, { now: () => new Date(), post: api.postOrder }) çağırır. Test isə sabit saat və aldığını yadda saxlayan funksiya ötürür:

TypeScript
test("stamps the order with the current time", async () => {
  const post = vi.fn(async (_order: Order) => {});
  const now = () => new Date("2026-11-16T10:00:00Z");

  await placeOrder({ items: [tea] }, { now, post });

  expect(post).toHaveBeenCalledWith({
    items: [tea],
    placedAt: "2026-11-16T10:00:00.000Z",
  });
});

Bu, dependency injection-dır (asılılıqların ötürülməsi): asılılıqları çağıran tərəf verir. Xüsusi alət tələb etmir və asılılıqları funksiyanın imzasında göstərir. React-də eyni ideya props (onSubmit) və ya context kimi görünür.

Nəticədə hərtərəfli test etmək ucuz olan böyük təmiz nüvə və cəmi bir neçə test tələb edən nazik komponent və adapter qatı alınır.

MiddleKonsepsiya

Test double-lar: dummy, stub, spy, mock və fake

test zamanı real asılılığın yerini tutan istənilən obyekt və ya funksiyadır, kino kaskadyorunun (stunt double) aktyorun yerini tutduğu kimi. Termini və double-ların beş növünü Gerard Meszaros xUnit Test Patterns (2007) kitabında təqdim edib; adətən Martin Fowler-in TestDouble və Mocks Aren't Stubs məqalələrindəki qısa təriflərə istinad olunur:

  • Dummy: ötürülür, amma heç vaxt istifadə olunmur; sadəcə parametr siyahısını doldurur. Məsələn, heç vaxt log yazmayan kod yolunda logger arqumenti.
  • Stub: test zamanı edilən çağırışlara əvvəlcədən hazırlanmış cavablar verir. getRates: () => ({ USD: 1.7 }) valyuta çevirməsini proqnozlaşdırıla bilən edir.
  • Spy: necə çağırıldığını da yadda saxlayan stub; test sonradan hansı mesajın "göndərildiyini" və neçə dəfə göndərildiyini yoxlaya bilər.
  • Mock: alacağı çağırışlarla bağlı gözləntilərlə əvvəlcədən proqramlaşdırılır. Gözləmədiyi çağırışda uğursuz ola bilər, sonda isə gözlənilən bütün çağırışların baş verdiyi yoxlanılır.
  • Fake: işləyən implementasiyadır, amma onu production üçün yararsız edən qısa yolu var, məsələn, verilənlər bazası əvəzinə datanı yaddaşda (in-memory) saxlayan repository.
TypeScript
// fake: real davranış, yaddaşda saxlanır
class InMemoryOrders implements OrderRepository {
  #orders = new Map<string, Order>();
  async save(order: Order) {
    this.#orders.set(order.id, order);
  }
  async findById(id: string) {
    return this.#orders.get(id) ?? null;
  }
}

Gündəlik danışıqda "mock"

vi.fn() hər çağırışı yadda saxlayan və proqramlaşdırdığın dəyəri qaytaran funksiya yaradır, yəni Meszaros-un terminləri ilə stub rolunu da oynaya bilən spy-dır. Vitest, Jest kimi, onu mock funksiya adlandırır və developer-lərin çoxu istənilən double-a deyir. Söhbətdə bu, problem deyil. Fərq nəyi yoxlayacağına qərar verəndə vacibdir:

  • Stub və ya fake ilə test olunan kodun nəticəsini yoxlayırsan: qaytarılan cəmi, sonda fake repository-də nəyin saxlandığını. Fowler bunu state verification (vəziyyətin yoxlanması) adlandırır.
  • Spy və ya mock ilə çağırışların özünü yoxlayırsan. Fowler bunu behaviour verification (davranışın yoxlanması) adlandırır, "double-ların bu növlərindən yalnız mock-lar davranışın yoxlanmasında israr edir" deyə qeyd edir və bu yolla yazılan testlərin "implementasiyaya daha sıx bağlı" olduğunu yazır.

Hansını seçməli

Real asılılıq sürətli və deterministikdirsə, məsələn, öz təmiz köməkçi funksiyalarındırsa, elə ondan istifadə et. Real olan yavaş və ya xaricidirsə, amma bir neçə çağırış boyu real davranış lazımdırsa (saxla, sonra tap), fake götür. Konkret cavab qaytartmaq üçün stub-dan istifadə et: xəta, boş siyahı, məzənnə. Çağırışları spy ilə yalnız çağırışın özü çağıran üçün vacib nəticə olanda yoxla, məsələn, email göndəriləndə və ya onSubmit form dəyərlərini alanda; qalan hallarda nəticəni yoxla.

MiddleFramework

vi.fn, vi.spyOn və onların bərpası

vi.fn(impl?) yeni mock funksiya yaradır. İmplementasiya verilməsə, undefined qaytarır; verilsə, onu işə salır və çağırışı yadda saxlayır:

TypeScript
import { expect, test, vi } from "vitest";

test("reports each failed upload", () => {
  const report = vi.fn();
  reportFailures([{ name: "a.png", ok: false }, { name: "b.png", ok: true }], report);

  expect(report).toHaveBeenCalledTimes(1);
  expect(report).toHaveBeenCalledWith("a.png failed");
});

Onu mockReturnValue(v), mockReturnValueOnce(v) (yalnız növbəti çağırış üçün), mockResolvedValue(v), mockRejectedValue(e) və ya mockImplementation(fn) ilə proqramlaşdır. toHaveBeenCalled, toHaveBeenCalledTimes, toHaveBeenCalledWith və toHaveBeenLastCalledWith ilə yoxla, ya da report.mock.calls-u (hər çağırış üçün arqumentlər massivi) və report.mock.results-u oxu. Tipli kodda vi.fn<typeof sendEmail>() yazsan, TypeScript proqramlaşdırdığın dəyərləri real imza ilə yoxlayır. Bir tələ: Vitest arqumentləri reference ilə saxlayır, yəni kod obyekti ötürdükdən sonra onu dəyişsə, toHaveBeenCalledWith dəyişmiş obyektlə müqayisə edir.

vi.spyOn(object, "method") mövcud obyektin metodunu default olaraq orijinalı çağırmağa davam edən mock ilə əvəz edir. Ondan real metodu izləmək üçün istifadə et, ya da davranışını əvəz etmək üçün .mockImplementation() və ya .mockReturnValue() zəncirlə:

TypeScript
const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
parseConfig({ retries: "3" });
expect(warn).toHaveBeenCalledWith("retries should be a number");
warn.mockRestore();

Clear, reset, restore

console kimi paylaşılan obyektə qoyulmuş spy, nəsə orijinalı geri qaytarmasa, testdən sonra da yerində qalır. Hər metod əvvəlkindən daha çox iş görür:

çağırış tarixçəsini silirimplementasiyanı sıfırlayırorijinal metodu geri qaytarır
mockClear()bəlixeyrxeyr
mockReset()bəlibəlixeyr
mockRestore()bəlibəlibəli, vi.spyOn üçün

"Sıfırlamaq" mock-un yaradıldığı vəziyyətə qayıtmaq deməkdir: vi.fn(impl) yenidən impl-ə, vi.fn() undefined qaytarmağa, vi.spyOn spy-ı isə real metodu çağırmağa qayıdır. vi.fn() mock-unda mockRestore() mockReset() ilə eyni işi görür.

vi.clearAllMocks() və vi.resetAllMocks() ilk ikisini bütün mock-lara tətbiq edir. vi.restoreAllMocks() isə yalnız vi.spyOn ilə əvəz olunmuş metodları geri qaytarır; tarixçəni silmir və implementasiyaları sıfırlamır. clearMocks, mockReset və restoreMocks config seçimləri onları hər testdən əvvəl avtomatik çağırır. Vitest 5-dən bəri clearMocks default olaraq aktivdir, mockReset və restoreMocks isə söndürülü qalır, ona görə testlər paylaşılan obyektlərə spy qoyursa, restoreMocks: true-nu aktiv et (və ya afterEach-də restore et).

MiddleKonsepsiya

Hazırlıq, təmizləmə və testlərin təcridi

Hər test tək, birinci və ya sonuncu işləməsindən asılı olmayaraq eyni nəticəni verməlidir. Dəyişkən state-i paylaşan testlər sıralarından asılı olaraq keçir və ya uğursuz olur:

TypeScript
// ✗ bütün fayl üçün bir səbət
const cart = createCart();

test("adds an item", () => {
  cart.add(tea);
  expect(cart.count()).toBe(1);
});

test("starts empty", () => {
  expect(cart.count()).toBe(0);
});

İkinci test birincidən sonra uğursuz olur, tək işə salınanda isə keçir. Hər test üçün təzə state yarat, testin içində və ya hook-da:

TypeScript
let cart: Cart;

beforeEach(() => {
  cart = createCart();
});

Vitest hook-ları cari fayla, describe blokunun içində elan olunanda isə həmin bloka aiddir: beforeEach və afterEach hər testin ətrafında, beforeAll və afterAll isə hamısının ətrafında bir dəfə işləyir. afterEach test uğursuz olanda da işləyir, ona görə təmizləmənin yeri oradır. beforeEach təmizləmə funksiyası da qaytara bilər; Vitest onu testdən sonra, afterEach hook-larından da sonra işə salır və beləliklə hazırlıq və təmizləmə yan-yana qalır. onTestFinished(fn) isə təmizləməni testin öz içindən qeydə alır.

TypeScript
beforeEach(() => {
  const spy = vi.spyOn(console, "error").mockImplementation(() => {});
  return () => spy.mockRestore();
});

Vitest nəyi təcrid edir, nəyi etmir

  • Test faylları default olaraq ayrı mühitlərdə işləyir (isolate: true), ona görə bir faylın modul state-i digərinə keçmir.
  • Eyni fayldakı testlər modul səviyyəsindəki dəyişənləri, globalThis-i, simulyasiya olunmuş DOM-u və restore olunmamış hər spy-ı paylaşır. Vitest onları yazıldıqları sıra ilə işə salır və bu, sıradan asılılığı gizlədir: yalnız başqa testdən sonra keçən test kimsə onu tək işə salana və ya sıranı --sequence.shuffle ilə qarışdırana qədər keçməyə davam edir.
  • Mock çağırışlarının tarixçəsi Vitest 5-dən bəri hər testdən əvvəl silinir (clearMocks: true), ona görə toHaveBeenCalledTimes(1) yalnız cari testin çağırışlarını sayır. mockReturnValue ilə verilmiş implementasiyalar mockReset aktiv deyilsə qalır, spy qoyulmuş metodlar isə restoreMocks aktiv deyilsə əvəz olunmuş qalır.

beforeAll-u testlərin yalnız oxuduğu baha hazırlıq üçün saxla; testin dəyişdiyi hər şey həmin test üçün yaradılmalıdır. Eyni qayda yaddaşdan kənarda da keçərlidir: eyni müvəqqəti fayla, verilənlər bazasının eyni sətirlərinə və ya eyni porta yazan testlər bir-birindən asılıdır və Vitest faylları paralel işə salanda toqquşa bilər.

SeniorTipik səhvlər

Həddindən artıq mock

Double asılılığın davranışını testdən çıxarır. Kent C. Dodds Write tests. Not too many. Mostly integration. məqaləsində xəbərdarlıq edir: "Nəyisə mock edəndə test etdiyin şeylə mock olunan şey arasındakı inteqrasiyaya olan bütün əminliyi aradan qaldırırsan." Hər yerdə istifadə olunan double-lar məhsul sınıq olanda da yaşıl qalan testlər yaradır.

TypeScript
vi.mock("./cart-store");
vi.mock("./pricing");
vi.mock("./orders-api");

test("checkout", async () => {
  vi.mocked(loadCart).mockResolvedValue(cart);
  vi.mocked(calculateTotal).mockReturnValue(42);

  await checkout("c1");

  expect(loadCart).toHaveBeenCalledWith("c1");
  expect(calculateTotal).toHaveBeenCalledWith(cart);
  expect(submitOrder).toHaveBeenCalledWith({ cartId: "c1", total: 42 });
});

Bu test implementasiyanı sətir-sətir təkrarlayır. Kod yenidən təşkil olunanda (qiymət hesablaması iki funksiyaya bölünəndə) sınır, calculateTotal səhv rəqəm qaytaranda isə keçir, çünki 42 sadəcə testin dediyi rəqəmdir.

Həddindən artıq mock-un əlamətləri:

  • assertion-ların çoxu layihənin öz modulları üzərində toHaveBeenCalledWith-dir;
  • stub-ların qaytardığı dəyərlər real asılılığın qaytardığından götürülmür, uydurulur və zaman keçdikcə ondan uzaqlaşır.

Nəyi əvəz etməli

Fowler iki üslubu təsvir edir. Klassik üslub "mümkünsə real obyektlərdən, real olandan istifadə etmək çətindirsə double-dan" istifadə edir; mockist üslubun tərəfdarı isə "maraqlı davranışı olan istənilən obyekt üçün həmişə mock-dan istifadə edəcək". Dodds eyni məqalədə "bu qədər çox şeyi mock etməyi dayandırmağı" daha çox inteqrasiya testi yazmaq üçün edə biləcəyin ən böyük addım adlandırır. Praktikada bu, öz modullarını (qiymət hesablaması, formatlama, reducer-lər, store) real saxlamaq və yavaş, deterministik olmayan və ya sənin prosesindən kənarda olanı əvəz etmək deməkdir: şəbəkəni, saatı, təsadüfiliyi, üçüncü tərəf SDK-larını. Əvəz edəndə sərhəddə əvəz et: kodunun hamısı fake HTTP qatı ilə real qatla işlədiyi kimi işləyir, öz fetch wrapper-inin stub-ı isə wrapper-in məntiqini ötürüb keçir.

Injection, yoxsa vi.mock?

vi.mock(path, factory?) test faylında modulu onu import edən hər yer üçün əvəz edir. Vitest bu çağırışı import-ların üstünə qaldırır (hoisting), Vitest 5-dən bəri isə çağırış faylın ən üst səviyyəsində deyilsə, xəta atır. Test olunan kodu dəyişmədən işləyir, ona görə ondan həddindən artıq istifadə etmək asandır: asılılıq kodda görünmür və əvəzetmə bütün fayla aiddir.

Ötürülən asılılıqlar (parametrlər, props, context) açıqdır və hər test üçün ayrıca seçilir. Praktik bölgü: sənə məxsus olanı və testdən testə dəyişəni parametr kimi ötür; vi.mock-u asanlıqla ötürülə bilməyən şeylər üçün saxla, məsələn, ağacın dərinliyində import olunan üçüncü tərəf modulu və ya import zamanı yan təsiri olan modul üçün.

SeniorKonsepsiya

Snapshot testlər və onların hüdudları

expect(value).toMatchSnapshot() dəyəri serializasiya edir və testin ilk işləməsində saxlanmış nüsxə ilə müqayisə edir; nüsxə testin yanındakı __snapshots__/<file>.snap faylında olur. toMatchInlineSnapshot() həmin nüsxəni test faylının özünə yazır və kiçik snapshot-ları yoxlandıqları yerdə görünən saxlayır.

TypeScript
test("formats a receipt", () => {
  expect(formatReceipt(order)).toMatchSnapshot();
});

Sonrakı run-larda istənilən fərq testi diff ilə uğursuz edir. Dəyişiklik qəsdəndirsə, saxlanmış nüsxəni vitest -u ilə və ya watch rejimində u düyməsi ilə yenilə. CI-da Vitest snapshot-ları heç vaxt yazmır, ona görə əskik, dəyişmiş və ya köhnəlmiş (obsolete) snapshot run-ı uğursuz edir. Snapshot faylları koddur: dəyişikliklə birlikdə commit və review olunur.

Snapshot-lar harada kömək edir

  • təsadüfən dəyişməməli olan böyük, strukturlu çıxış: serializer, generasiya olunmuş konfiqurasiya, formatlanmış xəta mesajı, CLI-ın çıxışı;
  • testsiz kodu refaktorinq etməzdən əvvəl təhlükəsizlik toru: cari çıxışı qeydə al, refaktorinq et, heç nəyin dəyişmədiyini təsdiqlə.

Onların hüdudları

  • Snapshot kodun nə etməli olduğunu yox, nə etdiyini qeydə alır. İlk run nə çıxsa qəbul edir, bug-lar da daxil. Kimsə saxlanmış dəyəri oxuyub onun düzgün olduğunu təsdiqləməlidir.
  • Böyük snapshot-lar baxılmadan təsdiqlənir. Səhifənin 300 sətirlik snapshot-u hər markup dəyişikliyində dəyişəndə review edənlər diff-i oxumağı dayandırır. Vitest guide-ı xəbərdarlıq edir ki, sınıq çıxışı "kor-koranə u basaraq" qəbul etmək asandır.
  • Default olaraq implementasiya detallarını test edirlər. Wrapper elementlər, class adları və atributların sırası davranış dəyişmədən dəyişir, ona görə bütöv komponentin snapshot-ları zərərsiz refaktorinqlərdə sınır və insanları baxmadan yeniləməyə öyrəşdirir.
  • Dinamik dəyərlər (tarixlər, generasiya olunan id-lər) hər run-da fərqlənir. toMatchSnapshot({ id: expect.any(Number) }) kimi property matcher-lər formanı sabitləyir, dəyəri isə nəzərə almır.

Vitest guide-ının qaydası: "çıxışda istənilən dəyişiklikdən qorunmaq istəyəndə snapshot-lardan, yalnız konkret xüsusiyyətlər vacib olanda isə hədəfli assertion-lardan istifadə et." Komponent üçün istifadəçinin gördüyü mətnə və ya role-a yazılmış assertion vacib olanı ifadə edir; bütöv markup-ın snapshot-u isə hər şeyi ifadə edir, yəni vacib olan barədə heç nə demir.

Pull request-dəki istənilən snapshot üçün faydalı review sualı: bu diff bug olsaydı, review edən onu görərdimi? Görməzdisə, snapshot-u bir neçə hədəfli assertion ilə əvəz et.

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

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

30 saniyəlik cavab. "Unit test kodu seçilmiş girişlərlə çağırır və çıxışları yoxlayır. Ən asan test olunan kod təmiz funksiyalardır, ona görə biznes qaydalarını komponentlərdən kənarda saxlayıram. Asılılıqlar üçün test double-lardan istifadə edirəm; Gerard Meszaros onları dummy, stub, spy, mock və fake növlərinə bölür, Vitest-də isə bu, əsasən vi.fn və vi.spyOn-dur. Real asılılıqlara və fake-lərə üstünlük verirəm, yalnız yavaş və ya deterministik olmayanı əvəz edirəm, imkan olanda modulları mock etmək əvəzinə asılılıqları ötürürəm, hər testdən sonra spy-ları restore edirəm və çağırışın özü davranış deyilsə, çağırışları yox, nəticələri yoxlayıram."

Gözlənilən suallar

  • toBe, toEqual, yoxsa toStrictEqual? Object.is ilə eynilik; undefined açarlara və class tiplərinə baxmayan rekursiv bərabərlik; onları da yoxlayan rekursiv bərabərlik.
  • Stub ilə mock arasında fərq nədir? Stub hazır cavablar qaytarır və sən nəticəni yoxlayırsan (state verification); mock isə alacağı çağırışlar barədə gözləntilər daşıyır (behaviour verification). Əsas mənbə Martin Fowler-in Mocks Aren't Stubs məqaləsidir.
  • vi.fn, yoxsa vi.spyOn? Yeni funksiya, yoxsa mövcud metodun ətrafında, sən əvəz edənə qədər orijinalı çağırmağa davam edən wrapper.
  • mockClear, mockReset, mockRestore? Tarixçə; tarixçə və implementasiya; bunların hamısı üstəgəl spy-lar üçün orijinal metodun geri qaytarılması.
  • Date.now() və ya Math.random()-dan istifadə edən kodu necə test edirsən? Saatı və ya təsadüfi dəyər mənbəyini parametr kimi ötür, vaxt üçün isə Vitest-in fake timer-lərindən və vi.setSystemTime-dan istifadə et.

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

  • Hər double-a mock demək və hər yerdə çağırışları yoxlamaq.
  • expect(() => fn()).toThrow() əvəzinə expect(fn()).toThrow() yazmaq.
  • .rejects və ya .resolves-u await etməmək.
  • Paylaşılan obyektə spy qoyub onu restore etməmək.
  • Test olunan modulu və ya layihənin öz təmiz modullarını mock etmək.

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

Alətlərdən yox, test oluna bilən dizayndan danış: nazik qabıqlı təmiz nüvə, parametr kimi ötürülən asılılıqlar və yalnız nəzarət etmədiyin sərhədlərdə double-lar. Altı mock-u olan testi dizayn problemi əlaməti kimi oxuduğunu və son dəyişiklikləri bildiyini göstər, məsələn, Vitest 5-in default olaraq hər testdən əvvəl mock tarixçəsini sildiyini və await olunmamış asinxron assertion-ları uğursuz etdiyini.

JuniorYoxlama siyahısı

Unit testləri və mock-ları review edərkən nəyi yoxlamalı

Özün yazmadığın unit testləri, məsələn, komanda yoldaşının pull request-ində və ya generasiya olunmuş kodda review edəndə bu siyahıdan istifadə et. Testlərdəki və double-lardakı səhvlər uğursuzluq kimi görünmür; sonradan "test olunmuş" bug-lar və hər refaktorinqdə sınan testlər kimi üzə çıxır.

  • Test olunan kod realdırmı, yalnız asılılıqları əvəz olunubmu? Test olunan funksiyanın import-unu tap və heç bir vi.mock və ya vi.spyOn-un onu əvəz etmədiyinə əmin ol; nəticəsini yoxladığı funksiyanın özünü stub edən test yalnız stub-ı test edir.
  • Assertion-lar nəticəni yoxlayır, yoxsa yalnız double-ların çağırıldığını? Çağırış nəticənin özüdürsə (göndərilən event, dəyərlərlə çağırılan onSubmit), toHaveBeenCalledWith yerindədir; bütün assertion-lar layihənin öz modullarına çağırış yoxlamasıdırsa, test implementasiyanı təkrarlayır və səhv dəyərləri buraxır.
  • Düzgün bərabərlik seçilibmi? Obyektlərdə toBe eyniliyi yoxlayır və bərabər nüsxələrdə uğursuz olur; toEqual undefined açarlara və class tiplərinə baxmır, ona görə dəqiq forma vacib olanda toStrictEqual, kəsr ədədlər üçün toBeCloseTo yaz.
  • Xətalar və promise-lər düzgün yoxlanılırmı? toThrow funksiya tələb edir, expect(() => fn()).toThrow("message"), və mesajı yoxlamalıdır; .resolves və .rejects await olunmalıdır, olunmasa, Vitest 5 testi uğursuz edir.
  • Hər spy restore olunurmu və hər test müstəqildirmi? console-a və ya başqa paylaşılan obyektə qoyulmuş vi.spyOn üçün mockRestore(), restoreMocks: true və ya afterEach-də təmizləmə lazımdır, testlər arasında paylaşılan state isə beforeEach tələb edir. Sıradan asılılığı üzə çıxarmaq üçün faylı --sequence.shuffle ilə işə sal.
  • Stub-ların dəyərləri real asılılığın qaytardığına uyğundurmu? Uydurulmuş forma (real API { unitPrice } qaytaranda { price }) testlərin əslində mövcud olmayan müqaviləyə görə keçməsinə imkan verir; double-ı vi.fn<typeof realFn>() və ya vi.mocked() ilə tiplə ki, TypeScript bu uyğunsuzluğu tutsun.
  • Hər snapshot kiçik, düzgün və izah olunubmu? Snapshot kodun ilk run-da çıxardığı hər şeyi qəbul edir, ona görə saxlanmış dəyəri oxu və diff-dəki hər yenilənmiş snapshot-un niyə dəyişdiyini soruş.

Ö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