Ilovalarni testlash
Nima uchun Node.js ilovalaringizni sinab ko‘ring?
Sinov ko‘plab afzalliklarni ta’minlovchi dasturiy ta’minotni ishlab chiqishning muhim qismidir:
- Xatolarni aniqlash: Xatolarni ishlab chiqarishgacha toping va tuzating
- Kod sifati: Kod sifati standartlarini joriy qiling va regressiyalarning oldini oling
- Hujjatlar: Testlar kodingiz uchun bajariladigan hujjat sifatida xizmat qiladi
- Ishonch: O‘zgartirishlar kiritish va kodni qayta ishlashga ishonch hosil qiling
- Hamkorlik: Jamoa a’zolariga kod qanday ishlashini tushunishga yordam bering
- CI/CD: Uzluksiz integratsiya va joylashtirish payplar (pipes)ini yoqish
Node.js da test turlari
Birlik sinovi
Unit testlar alohida komponentlarning (funksiyalar, metodlar, klasslar) izolyatsiyada kutilganidek ishlashini tekshiradi; bunda odatda bog‘liqliklar uchun mock’lardan foydalaniladi.
Misol: Node.js Assert bilan birlik sinovi
kalkulyator.js
function add(a, b) {
if (typeof a !== 'number' || typeof b !== 'number') {
throw new Error('Both arguments must be numbers');
}
return a + b;
}
function subtract(a, b) {
if (typeof a !== 'number' || typeof b !== 'number') {
throw new Error('Both arguments must be numbers');
}
return a - b;
}
module.exports = { add, subtract };
test/calculator.test.js
const assert = require('assert');
const { add, subtract } = require('./calculator');
// Test the add function
assert.strictEqual(add(1, 2), 3, 'Addition not working correctly');
assert.strictEqual(add(-1, 1), 0, 'Addition with negative numbers not working');
// Test the subtract function
assert.strictEqual(subtract(5, 2), 3, 'Subtraction not working correctly');
assert.strictEqual(subtract(2, 5), -3, 'Subtraction resulting in negative not working');
console.log('All tests passed!');
Misolni ishga tushirish »
Integratsiya testi
Integratsiya testlari ma’lumotlar bazasi operatsiyalari, API so‘nggi nuqtalari yoki uchinchi tomon xizmatlarining o‘zaro ta’sirini sinab ko‘rish kabi bir nechta komponentlarning to‘g‘ri ishlashini tasdiqlaydi.
Misol: Oddiy API so‘nggi nuqtasini sinovdan o‘tkazish
app.js
const express = require('express');
const app = express();
app.get('/users', (req, res) => {
res.json([
{ id: 1, name: 'Alice' },
{ id: 2, name: 'Bob' }
]);
});
module.exports = app;
test.js
const assert = require('assert');
const http = require('http');
const app = require('./app');
// Start the server
const server = app.listen(8080);
// Make a request to the API
http.get('http://localhost:8080/users', (res) => {
let data = '';
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
const users = JSON.parse(data);
// Verify the response
assert.strictEqual(res.statusCode, 200, 'Status code should be 200');
assert.strictEqual(users.length, 2, 'Should return two users');
assert.strictEqual(users[0].name, 'Alice', 'First user should be Alice');
assert.strictEqual(users[1].name, 'Bob', 'Second user should be Bob');
console.log('API test passed!');
// Close the server
server.close();
});
}).on('error', (err) => {
console.error('Test failed:', err);
server.close();
});
Misolni ishga tushirish »
Oxir-oqibat sinov
Yakuniy testlar haqiqiy foydalanuvchi stsenariylari va o‘zaro ta’sirlarini simulyatsiya qilib, boshidan oxirigacha butun dastur oqimini tekshiradi.
Bu testlar odatda Playwright, Cypress yoki Vebdriver.IO brauzerini avtomatik tarzda ishlash uchun kabi vositalardan foydalanadi.
Eslatma: Oxir-oqibat sinovlarni sozlash va saqlash ancha murakkab, ammo ilovangiz funksionalligini eng to‘liq tekshirishni ta’minlaydi.
Testga asoslangan ishlab chiqish (TDD)
Sinovga asoslangan ishlab chiqish dasturiy ta’minotni ishlab chiqish yondashuvidir, bunda siz:
- Funksiya yoki yaxshilanishni belgilaydigan test yozing
- Sinovni bajaring, bu funksiya hali mavjud emasligi sababli muvaffaqiyatsiz bo‘lishi mumkin
- Sinovdan o‘tish uchun eng oddiy kodni yozing
- Refactor kodni sifat standartlariga javob berish uchun
- Har bir yangi xususiyat yoki yaxshilanish uchun takrorlang
TDD misoli: Parolni tekshirish vositasini ishlab chiqish
password-validator.test.js
// 1. Write the test first
const assert = require('assert');
const validatePassword = require('./password-validator');
// Test for password length
assert.strictEqual(validatePassword('abc12'), false, 'Should reject passwords shorter than 8 characters');
assert.strictEqual(validatePassword('abcdef123'), true, 'Should accept passwords 8+ characters long');
// Test for number requirement
assert.strictEqual(validatePassword('abcdefgh'), false, 'Should reject passwords without numbers');
assert.strictEqual(validatePassword('abcdefg1'), true, 'Should accept passwords with numbers');
console.log('All password validation tests passed!');
// 2. Run the test - it will fail because validatePassword doesn't exist yet
password-validator.js
// 3. Write the simplest code to pass the tests
function validatePassword(password) {
// Check length (at least 8 characters)
if (password.length < 8) {
return false;
}
// Check if it contains at least one number
if (!/\d/.test(password)) {
return false;
}
return true;
}
module.exports = validatePassword;
// 4. Run the tests again - they should pass now
// 5. Refactor if needed, then repeat for new requirements
Misolni ishga tushirish »
Eng yaxshi tajribalarni sinovdan o‘tkazish
Sinov kodini yozing
- Yagona javobgarlik printsipi: Har bir funksiya bitta ishni yaxshi bajarishi kerak
- Sof funksiyalar: Nojo‘ya ta’sirlarsiz bir xil kirish uchun bir xil chiqishni ishlab chiqaradigan funksiyalarni sinab ko‘rish osonroq.
- Tobelikni kiritish: Bog‘liqlarni ularni ichida yaratishdan ko‘ra, funksiyalarga o‘tkazing
Test tashkil etish
- Guruhga aloqador testlar: Tegishli funksiyalar uchun testlarni birga saqlang
- Tasviriy test nomlari: Test nimani tasdiqlayotganini tushuntiruvchi aniq nomlardan foydalaning
- Sozlash va buzish: Sinov ma’lumotlarini to‘g‘ri sozlang va sinovlardan keyin tozalang
Sinov qamrovi
Yuqori sinov qamrovini maqsad qilib qo‘ying, lekin muhim yo‘llar va chekka holatlarga ustunlik bering:
- Happy Path: Kutilgan normal oqimni sinab ko‘ring
- Edge Cases: Chegara shartlari va noodatiy kirishlarni sinab ko‘ring
- Xatolarni qayta ishlash: Xatolar to‘g‘ri ishlaganligini tekshiring
Sinov vaqtini hisobga olish
Mazax qilish
Sinov qilinayotgan kodni izolyatsiya qilish uchun haqiqiy bog‘liqliklarni test juftlari bilan almashtiring:
Misol: Ma’lumotlar bazasi ulanishini mock qilish (simulyatsiya qilish)
user-service.js
class UserService {
constructor(database) {
this.database = database;
}
async getUserById(id) {
const user = await this.database.findById(id);
if (!user) {
throw new Error('User not found');
}
return user;
}
}
module.exports = UserService;
user-service.test.js
const assert = require('assert');
const UserService = require('./user-service');
// Create a mock database
const mockDatabase = {
findById: async (id) => {
// Mock implementation returns test data
if (id === 1) {
return { id: 1, name: 'Alice', email: 'alice@example.com' };
}
return null;
}
};
async function testUserService() {
const userService = new UserService(mockDatabase);
// Test successful retrieval
const user = await userService.getUserById(1);
assert.strictEqual(user.name, 'Alice', 'Should retrieve correct user name');
// Test error handling
try {
await userService.getUserById(999);
assert.fail('Should have thrown an error for non-existent user');
} catch (error) {
assert.strictEqual(error.message, 'User not found', 'Should throw user not found error');
}
console.log('UserService tests passed!');
}
testUserService().catch(err => {
console.error('Test failed:', err);
});
Misolni ishga tushirish »
Asinxron kodni sinovdan o‘tkazish
Node.js ilovalari ko‘pincha asinxron operatsiyalarni o‘z ichiga oladi.
Sinovlaringiz asenkron kodni to‘g‘ri ishlashiga ishonch hosil qiling.
Misol: Asinxron funksiyalarni sinash
async-service.js
class AsyncService {
async fetchData() {
return new Promise((resolve) => {
setTimeout(() => {
resolve({ status: 'success', data: [1, 2, 3] });
}, 100);
});
}
async processData() {
const result = await this.fetchData();
return result.data.map(num => num * 2);
}
}
module.exports = AsyncService;
async-service.test.js
const assert = require('assert');
const AsyncService = require('./async-service');
async function testAsyncService() {
const service = new AsyncService();
// Test fetchData
const fetchResult = await service.fetchData();
assert.strictEqual(fetchResult.status, 'success', 'Should return success status');
assert.deepStrictEqual(fetchResult.data, [1, 2, 3], 'Should return correct data array');
// Test processData
const processResult = await service.processData();
assert.deepStrictEqual(processResult, [2, 4, 6], 'Should double each value in the array');
console.log('AsyncService tests passed!');
}
testAsyncService().catch(err => {
console.error('Test failed:', err);
});
Misolni ishga tushirish »
Uzluksiz integratsiya (CI)
Sinovlaringizni uzluksiz integratsiya bilan avtomatlashtirish ularning muntazam ishlashini ta’minlaydi:
- Sinov to‘plamini har bir kodni surish yoki tortib olish so‘rovida ishlashi uchun sozlang
- Sinovlarda muvaffaqiyatsizlikka uchragan kodni birlashtirishni oldini oling
- Vaqt o‘tishi bilan test qamrovini kuzatib boring
Node.js CI/CD qo‘llanmamizda CI/CD payplar (pipes)ini sozlash haqida ko‘proq bilib oling.
Xulosa
- Ishonchli Node.js ilovalarini yaratish uchun sinov juda muhim
- Turli test turlari (unit, integratsion, end-to-end) turli maqsadlarga xizmat qiladi
- Testga asoslangan ishlab chiqish (TDD) kod sifati va dizaynini yaxshilashi mumkin
- Yaxshi dasturiy ta’minotni loyihalash amaliyotiga rioya qilib, sinovdan o‘tkaziladigan kodni yozing
- Loyihangiz ehtiyojlari uchun tegishli test vositalari va frameworklardan foydalaning
- Uzluksiz integratsiya bilan sinovni avtomatlashtirish
W3Schools Pathfinder
Yutuqlaringizni kuzating – bu bepul!