Chapter 50 — Testing Asoslari

Bu bobda kodni avtomatik tekshirish — dasturiy testlashning asoslarini o'rganamiz. Bu — professional dasturlashning ajralmas qismi.

---

50.1 Nima uchun test yozish kerak?

Simple Explanation

Test — kodning kutilgan natijani berishini avtomatik ravishda tekshiruvchi, o'zi ham kod bo'lgan dastur.

Why Does It Exist?

Loyiha kattalashgan sari, bitta joyni o'zgartirish boshqa joyda kutilmagan xatoga olib kelishi mumkin. Testlar — bunday "yashirin" xatolarni, kod ishga tushirilishidan oldin, avtomatik ravishda aniqlaydi.

Real-Life Analogy

🔬 Test yozish — bu ko'prik qurilgandan keyin, unga haqiqiy mashinalar o'tishidan oldin, avtomatik sensorlar bilan mustahkamligini tekshirishga o'xshaydi. Har safar ko'prikka biror o'zgarish kiritilganda, sensorlar qayta tekshiradi — "hali ham mustahkammi?"

50.2 Test turlari

Jadval

💡 Key Idea
Bu bobda asosan Unit Testlarga e'tibor qaratamiz, chunki ular eng ko'p yoziladigan va JavaScript function'larini (kitobning Chapter 6-46'da o'rgangan barcha function turlarini) tekshirish uchun eng mos keladi.

50.3 Test Framework — Jest bilan tanishuv

Simple Explanation

Jest — JavaScript uchun eng mashhur test framework'laridan biri, u testlarni yozish va ishga tushirish uchun tayyor vositalarni taqdim etadi.

Asosiy tuzilma

script.js
JavaScriptNusxalash
01// mathUtils.js
02function add(a, b) {
03    return a + b;
04}
05 
06module.exports = { add };

script.js
JavaScriptNusxalash
01// mathUtils.test.js
02const { add } = require("./mathUtils");
03 
04test("2 va 3 ni qo'shish 5 ni beradi", function () {
05    expect(add(2, 3)).toBe(5);
06});

How It Works

• test(description, callback) — bitta test holatini belgilaydi, description — testning nima qilishini tushuntiruvchi matn.
• expect(value) — tekshirilayotgan qiymatni "o'raydi".
• .toBe(expected) — matcher, kutilgan natija bilan solishtiradi.

Buyruq orqali ishga tushirish

terminal.sh
BashNusxalash
01npm test

🔗 Connection
Bu — Chapter 49'da o'rgangan package.jsondagi "scripts": { "test": "jest" } orqali ishga tushiriladi.

50.4 Asosiy Jest Matcher'lari

Jadval

⚠️ Qiyin mavzu: toBe vs toEqual

Bu — Chapter 8/16'da o'rgangan reference type tushunchasi bilan bevosita bog'liq.

script.js
JavaScriptNusxalash
01test("Object'larni solishtirish", function () {
02    let obj1 = { name: "Ali" };
03    let obj2 = { name: "Ali" };
04 
05    expect(obj1).toBe(obj2);     // ❌ FAILS — ikkalasi turli object'lar (reference)
06    expect(obj1).toEqual(obj2);  // ✅ PASSES — mazmuni bir xil
07});

Explanation

toBe() — Chapter 8.7'da o'rgangan === operatoriga o'xshab, aynan bir xil obyektga ishora qilishni talab qiladi (reference tenglik). toEqual() esa — obyektlarning ichidagi qiymatlarini solishtiradi (chuqur tenglik, "deep equality"), garchi ular xotirada boshqa-boshqa obyektlar bo'lsa ham.

⚠️ Common Mistake
Object yoki array'larni solishtirishda .toBe() ishlatish — deyarli har doim testni "muvaffaqiyatsiz" qiladi, chunki ikkita alohida yaratilgan (garchi bir xil mazmunli) obyekt — hech qachon === bo'yicha teng emas. Bunday hollarda har doim .toEqual() ishlatilishi kerak.

50.5 Asinxron kodni test qilish

Simple Explanation

Chapter 26-28'da o'rgangan asinxron function'larni test qilish uchun, Jest'da async/await to'g'ridan-to'g'ri ishlatiladi.

Example

script.js
JavaScriptNusxalash
01async function fetchUserName(id) {
02    // haqiqiy loyihada bu yerda fetch() chaqirilardi (Chapter 37)
03    return "Ali";
04}
05 
06test("fetchUserName to'g'ri ismni qaytaradi", async function () {
07    let name = await fetchUserName(1);
08    expect(name).toBe("Ali");
09});

🔗 Connection
Bu — Chapter 28'da o'rgangan async/await bilimining, test yozishdagi to'g'ridan-to'g'ri qo'llanilishi: test function'ining o'zi ham async bo'lishi mumkin.

50.6 ⚠️ Qiyin mavzu: Mocking (Soxta obyektlar)

Simple Explanation

Mock — haqiqiy function yoki modul o'rniga ishlatiladigan, "soxta" (sun'iy) versiya. Bu, ayniqsa, tarmoq so'rovlari (Chapter 37) yoki tasodifiy qiymatlar (Chapter 10) kabi ishonchsiz yoki sekin narsalarni test qilishda foydali.

Nega bu kerak?

Agar test haqiqiy serverga so'rov yuborsa (Chapter 37'dagi fetch), test — internet aloqasiga, server holatiga bog'liq bo'lib qoladi, bu esa testlarni ishonchsiz va sekin qiladi.

Example — function'ni mock qilish

script.js
JavaScriptNusxalash
01function processPayment(amount, paymentGateway) {
02    if (amount <= 0) {
03        throw new Error("Noto'g'ri summa");
04    }
05    return paymentGateway.charge(amount);
06}
07 
08test("processPayment paymentGateway.charge'ni chaqiradi", function () {
09    let mockGateway = {
10        charge: jest.fn(() => "muvaffaqiyatli")
11    };
12 
13    let result = processPayment(100, mockGateway);
14 
15    expect(mockGateway.charge).toHaveBeenCalledWith(100);
16    expect(result).toBe("muvaffaqiyatli");
17});

How It Works

1. jest.fn(() => "muvaffaqiyatli") — haqiqiy charge metodi o'rniga ishlatiladigan soxta function yaratadi.
2. Bu mock — haqiqiy to'lov tizimiga ulanmasdan, uning xatti-harakatini simulyatsiya qiladi.
3. toHaveBeenCalledWith(100) — mock function qanday argumentlar bilan chaqirilganini tekshiradi — bu, function to'g'ri ishlaganini tasdiqlashning qo'shimcha usuli.

🔥 Important
Mocking — Chapter 37'dagi fetch() kabi tashqi bog'liqliklarni test qilishda muhim texnika: haqiqiy server so'rovi yubormasdan, "agar server shunday javob bersa, mening kodim to'g'ri ishlaydimi?" degan savolga javob berish imkonini beradi.

📝 Practice Exercises

🟢 Exercise 1 — Easy

Task:
Chapter 9'dagi toUpperCase() metodini ishlatuvchi oddiy function uchun Jest test yozing: shout(text) — matnni katta harflarga o'tkazadi, "!" qo'shadi.
Required Concepts:

• test(), expect().toBe()
  Hint:
  expect(shout("salom")).toBe("SALOM!");

🟡 Exercise 2 — Medium

Task:
Chapter 7'dagi array metodlarini ishlatuvchi getEvenNumbers(arr) function uchun test yozing (.toEqual() bilan, chunki natija — array).
Required Concepts:

• toEqual() array uchun
  Hint:
  expect(getEvenNumbers([1,2,3,4])).toEqual([2,4]);

🔴 Exercise 3 — Hard

Task:
Chapter 18'dagi kabi xatolik chiqaruvchi divide(a, b) function uchun (agar b === 0 bo'lsa xatolik chiqarsin), .toThrow() matcheri bilan test yozing. Bundan tashqari, jest.fn() yordamida oddiy "logger" mockini yaratib, divide funksiyasi muvaffaqiyatli natijani logger orqali "yozib qo'yishini" tekshiring.
Required Concepts:

• toThrow(), jest.fn()
  Hint:
  expect(() => divide(5, 0)).toThrow();

🔮 Predict the Output

script.js
JavaScriptNusxalash
01test("Array solishtirish", function () {
02    let arr1 = [1, 2, 3];
03    let arr2 = [1, 2, 3];
04 
05    expect(arr1).toBe(arr2);
06});

Bu test muvaffaqiyatli o'tadimi (PASS) yoki muvaffaqiyatsiz (FAIL) bo'ladimi?

🧠 Think first! Javobni ko'rishdan oldin kamida 30 soniya o'ylang.

<details> <summary>Answer</summary> FAIL (muvaffaqiyatsiz).

Why?
arr1 va arr2 — ikkita alohida array (Chapter 7.7, reference type), garchi ularning ichidagi qiymatlar bir xil bo'lsa ham. .toBe() — reference tenglikni (===) tekshiradi, shuning uchun bu test FAIL bo'ladi. .toEqual() ishlatilganda edi, test PASS bo'lardi.

</details>

🐛 Debugging Challenge

Quyidagi testda muammo bor:

script.js
JavaScriptNusxalash
01function getUser() {
02    return { name: "Ali", age: 25 };
03}
04 
05test("getUser to'g'ri ma'lumot qaytaradi", function () {
06    let user = getUser();
07    expect(user).toBe({ name: "Ali", age: 25 }); // FAIL bo'ladi
08});

Your Task:

• Nima uchun bu test muvaffaqiyatsiz bo'lishini tushuntiring.
• Testni tuzating.

<details> <summary>Solution</summary> Muammo: getUser() qaytargan object va testda qo'lda yozilgan { name: "Ali", age: 25 } — ikkalasi ham bir xil mazmunga ega, lekin xotirada ikkita alohida obyekt. .toBe() bu holatda ishlamaydi.

Yechim:

script.js
JavaScriptNusxalash
01test("getUser to'g'ri ma'lumot qaytaradi", function () {
02    let user = getUser();
03    expect(user).toEqual({ name: "Ali", age: 25 }); // PASS
04});

</details>

📌 Chapter Summary

• Test — kodning to'g'ri ishlashini avtomatik tekshiruvchi qo'shimcha kod.
• Unit, Integration, E2E — testlarning asosiy turlari, miqyosi bo'yicha farqlanadi.
• Jest — test(), expect(), va turli matcher'lar orqali ishlaydigan mashhur framework.
• .toBe() — reference tenglik, .toEqual() — mazmun tengligi uchun ishlatiladi.
• Mocking — tashqi bog'liqliklarni (server, tasodifiy son) test qilishda "soxta" versiyalar bilan almashtirish.

🎯 Key Takeaways

• Object va array'larni solishtirishda, deyarli har doim .toEqual() ishlating, .toBe() emas.
• Testlar — kodni o'zgartirganda, eski funksionallik "buzilmaganini" tezda tekshirish imkonini beradi.
• async testlar — asinxron kodni (Chapter 26-28) xuddi oddiy sinxron kod kabi test qilish imkonini beradi.
• Mocking — testlarni tezroq va ishonchliroq qiladi, tashqi resurslarga bog'liqlikni yo'qotadi.
• Test yozish — kodning o'zini yaxshiroq, kichik va "test qilinadigan" function'larga (Chapter 6, 14) bo'lishga undaydi.

⚡ Quick Cheat Sheet

script.js
JavaScriptNusxalash
01test("tavsif", function () {
02    expect(actualValue).toBe(expectedValue);
03    expect(obj).toEqual(expectedObj);
04    expect(value).toBeTruthy();
05    expect(array).toContain(item);
06    expect(() => fn()).toThrow();
07});
08 
09test("async test", async function () {
10    let result = await someAsyncFunc();
11    expect(result).toBe(expected);
12});
13 
14let mockFn = jest.fn(() => "natija");
15expect(mockFn).toHaveBeenCalledWith(arg);

---