JavaScript kodni testlash

Kodni har o’zgartirishda qo’lda tekshirish uzoq va ishonchsiz. Test — kodni tekshiradigan kod: bir marta yoziladi, har safar avtomatik ishlaydi.

Nima uchun kerak

Asosiy foyda — regressiyadan himoya: eski kodni o’zgartirganda nimadir buzilsa, test darhol aytadi.

Testsiz tekshiruv

Avval oddiy yondashuvni ko’ramiz:

JavaScript

function chegirma(narx, foiz) {
if (typeof narx !== "number" || narx < 0) {
  throw new Error("narx musbat son bo'lishi kerak");
}
if (foiz < 0 || foiz > 100) {
  throw new RangeError("foiz 0-100 oralig'ida");
}
return Math.round(narx * (1 - foiz / 100));
}

// Qo'lda tekshirish
console.log(chegirma(100000, 10));
console.log(chegirma(100000, 0));
console.log(chegirma(99999, 33));

Har o’zgarishdan keyin natijalarni ko’z bilan solishtirish kerak. Test buni avtomatlashtiradi.

Oddiy test yozuvchi

Kutubxonasiz ham tamoyilni ko’rsatish mumkin:

JavaScript

let otdi = 0, yiqildi = 0;

function test(nom, amal) {
try {
  amal();
  otdi++;
  console.log("✓ " + nom);
} catch (xato) {
  yiqildi++;
  console.log("✗ " + nom + " — " + xato.message);
}
}

function kutilgan(qiymat) {
return {
  teng(kutilyapti) {
    if (qiymat !== kutilyapti) {
      throw new Error("kutilgan " + kutilyapti + ", olingan " + qiymat);
    }
  },
  xatoBeradi() {
    if (typeof qiymat !== "function") throw new Error("funksiya kerak");
    try {
      qiymat();
    } catch {
      return;
    }
    throw new Error("xato kutilgan edi, lekin bo'lmadi");
  },
};
}

function chegirma(narx, foiz) {
if (foiz < 0 || foiz > 100) throw new RangeError("foiz 0-100");
return Math.round(narx * (1 - foiz / 100));
}

test("10% chegirma to'g'ri hisoblanadi", () => {
kutilgan(chegirma(100000, 10)).teng(90000);
});

test("0% chegirmada narx o'zgarmaydi", () => {
kutilgan(chegirma(100000, 0)).teng(100000);
});

test("natija yaxlitlanadi", () => {
kutilgan(chegirma(99999, 33)).teng(66999);
});

test("noto'g'ri foizda xato beradi", () => {
kutilgan(() => chegirma(100, 150)).xatoBeradi();
});

console.log("—");
console.log("O'tdi: " + otdi + ", yiqildi: " + yiqildi);

Haqiqiy test kutubxonalari ham aynan shu ishni bajaradi — faqat ancha boyroq imkoniyatlar bilan.

Vitest bilan

npm install -D vitest

package.json ga:

{
  "scripts": {
    "test": "vitest"
  }
}

chegirma.js:

export function chegirma(narx, foiz) {
  if (foiz < 0 || foiz > 100) throw new RangeError("foiz 0-100");
  return Math.round(narx * (1 - foiz / 100));
}

chegirma.test.js:

import { describe, it, expect } from "vitest";
import { chegirma } from "./chegirma.js";

describe("chegirma", () => {
  it("10% chegirmani to'g'ri hisoblaydi", () => {
    expect(chegirma(100000, 10)).toBe(90000);
  });

  it("0% da narxni o'zgartirmaydi", () => {
    expect(chegirma(100000, 0)).toBe(100000);
  });

  it("noto'g'ri foizda xato beradi", () => {
    expect(() => chegirma(100, 150)).toThrow(RangeError);
  });
});

Ishga tushirish: npm test.

AAA naqshi

Har test uch qismdan iborat bo’lsin:

it("savatga mahsulot qo'shadi", () => {
  // Arrange — tayyorlash
  const savat = yangiSavat();
  const mahsulot = { nom: "Olma", narx: 12000 };

  // Act — bajarish
  savat.qosh(mahsulot);

  // Assert — tekshirish
  expect(savat.soni()).toBe(1);
  expect(savat.jami()).toBe(12000);
});

Bu tuzilma testni o’qishni osonlashtiradi va bitta testda bir necha ishni tekshirishdan saqlaydi.

Asosiy matcherlar

Matcher	Tekshiradi
`toBe(x)`	Aynan tenglik (`===`) — sonlar, matnlar
`toEqual(x)`	Tuzilma tengligi — obyekt va massivlar
`toBeCloseTo(x)`	Kasr sonlar (yaxlitlash xatosi bilan)
`toContain(x)`	Massiv yoki matn ichida bormi
`toThrow()`	Xato beradimi
`toHaveLength(n)`	Uzunlik

toBe va toEqual farqi

Obyektlar uchun toBe ishlamaydi — u bir xil obyektmi deb so’raydi:

expect({ a: 1 }).toBe({ a: 1 });      // ❌ yiqiladi
expect({ a: 1 }).toEqual({ a: 1 });   // ✅ o'tadi

Kasr sonlarda ham ehtiyot: 0.1 + 0.2 !== 0.3 — sonlar darsidagi sabab. U yerda toBeCloseTo.

Nimani sinash kerak

JavaScript

function yoshGuruhi(yosh) {
if (yosh < 0) throw new RangeError("yosh manfiy bo'lolmaydi");
if (yosh < 13) return "bola";
if (yosh < 18) return "o'smir";
if (yosh < 60) return "katta";
return "keksa";
}

// Chegara qiymatlar — eng ko'p xato shu yerda
const sinovlar = [
[0, "bola"], [12, "bola"], [13, "o'smir"],
[17, "o'smir"], [18, "katta"],
[59, "katta"], [60, "keksa"],
];

for (const [yosh, kutilgan] of sinovlar) {
const olingan = yoshGuruhi(yosh);
console.log((olingan === kutilgan ? "✓" : "✗") + " " + yosh + " → " + olingan);
}

Ustuvorlik tartibi:

Chegara qiymatlar — 0, bo’sh massiv, null, chegaraning ikki tomoni;
Xato holatlari — noto’g’ri kirish;
Asosiy holat — odatiy ishlash;
Tuzatilgan xatolar — har buzilgan joyga test yoziladi, qaytmasligi uchun.

Testga qulay kod

JavaScript

// Sinash qiyin: tashqi holatga bog'liq va yon ta'siri bor
let jami = 0;
function qoshYomon(narx) {
jami += narx;
console.log("Jami: " + jami);
}

// Sinash oson: sof funksiya
function qoshYaxshi(joriy, narx) {
return joriy + narx;
}

console.log(qoshYaxshi(0, 100));
console.log(qoshYaxshi(100, 250));
console.log(qoshYaxshi(0, 100));

Sof funksiyalar testga eng qulay: tayyorgarlik kerak emas, natija bashorat qilinadi.

Tashqi bog’liqlikni argument sifatida uzatish ham yordam beradi:

// Qiyin: ichida vaqtga bog'lanadi
function eskirdimi(sana) {
  return Date.now() - sana > 86400000;
}

// Oson: vaqt tashqaridan beriladi
function eskirdimi(sana, hozir = Date.now()) {
  return hozir - sana > 86400000;
}

Qamrov haqida

Amaliy mashq

Sodda funksiya yozing va uni qo’lda tekshiring;
yuqoridagi test/kutilgan yordamchisi bilan uni sinang;
chegara qiymatlar uchun test qo’shing;
xato beradigan holatni sinang;
toBe va toEqual farqini obyektda ko’ring;
tashqi holatga bog’liq funksiyani sof qilib qayta yozing.

Qisqacha xulosa

Test — kodni tekshiradigan kod; regressiyadan himoya qiladi.
Birlik testlari ko’p va tez, E2E kam va sekin.
AAA: Arrange → Act → Assert.
Obyekt uchun toEqual, aniq qiymat uchun toBe, kasr uchun toBeCloseTo.
Avval chegara va xato holatlarini sinang.
Sof funksiya va tashqaridan uzatilgan bog’liqlik testni osonlashtiradi.

Keyingi darsda tezlik va optimallashtirish.