Jassif Team Institution

உங்கள் Node.js பயன்பாடுகளை ஏன் சோதிக்க வேண்டும்?

சோதனை என்பது மென்பொருள் உருவாக்கத்தின் ஒரு அத்தியாவசிய பகுதியாகும், இது பல நன்மைகளை வழங்குகிறது:

Node.js இல் சோதனை வகைகள்

அலகு சோதனை (Unit Testing)

அலகு சோதனைகள் தனிப்பட்ட கூறுகள் (செயல்பாடுகள், முறைகள், வகுப்புகள்) எதிர்பார்த்தபடி வேலை செய்கின்றனவா என்பதை சார்புகளுக்கான மோக் பயன்படுத்தி தனிமைப்படுத்தப்பட்ட நிலையில் சரிபார்க்கின்றன.

எடுத்துக்காட்டு: Node.js Assert உடன் அலகு சோதனை

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 };

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!');

ஒருங்கிணைப்பு சோதனை (Integration Testing)

ஒருங்கிணைப்பு சோதனைகள் பல கூறுகள் சரியாக ஒன்றாக வேலை செய்கின்றனவா என்பதை சரிபார்க்கின்றன, தரவுத்தள செயல்பாடுகள், API இறுதிப்புள்ளிகள் அல்லது மூன்றாம் தர சேவை தொடர்புகளை சோதிப்பது போன்றவை.

எடுத்துக்காட்டு: எளிய API இறுதிப்புள்ளியை சோதித்தல்

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;

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();
});

முழுமையான சோதனை (End-to-End Testing)

முழுமையான சோதனைகள் தொடக்கத்திலிருந்து இறுதிவரை முழு பயன்பாட்டு ஓட்டத்தை சரிபார்க்கின்றன, உண்மையான பயனர் காட்சிகள் மற்றும் தொடர்புகளை உருவகப்படுத்துகின்றன.

சோதனை-வழங்கிய மேம்பாடு (TDD)

சோதனை-வழங்கிய மேம்பாடு என்பது ஒரு மென்பொருள் உருவாக்க அணுகுமுறையாகும், இதில் நீங்கள்:

TDD எடுத்துக்காட்டு: கடவுச்சொல் சரிபார்ப்பியை உருவாக்குதல்

// 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

// 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

சோதனை சிறந்த நடைமுறைகள்

சோதிக்கக்கூடிய குறியீட்டை எழுதுங்கள்

சோதனை அமைப்பு

சோதனை கவரேஜ்

அதிக சோதனை கவரேஜை நோக்கமாகக் கொள்ளுங்கள், ஆனால் முக்கியமான பாதைகள் மற்றும் விளிம்பு வழக்குகளை முன்னுரிமையாகக் கொள்ளுங்கள்:

சோதனை இயக்க நேர பரிசீலனைகள்

மோக்கிங் (Mocking)

சோதிக்கப்படும் குறியீட்டை தனிமைப்படுத்த உண்மையான சார்புகளை சோதனை நகல்களுடன் மாற்றவும்:

எடுத்துக்காட்டு: தரவுத்தள இணைப்பை மோக்கிங் செய்தல்

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;

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);
});

அசிங்க்ரோனஸ் குறியீட்டை சோதித்தல்

Node.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;

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);
});

தொடர்ச்சியான ஒருங்கிணைப்பு (CI)

தொடர்ச்சியான ஒருங்கிணைப்புடன் உங்கள் சோதனைகளை தானியங்கி செய்வது அவை தவறாமல் இயங்குவதை உறுதிப்படுத்துகிறது:

சுருக்கம்

பயிற்சி