ജെസ്റ്റ്: കരുത്തുറ്റ സോഫ്റ്റ്‌വെയറിനായുള്ള നൂതന ടെസ്റ്റിംഗ് പാറ്റേണുകൾ

ഇന്നത്തെ അതിവേഗ സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെന്റ് ലോകത്ത്, നിങ്ങളുടെ കോഡ്‌ബേസിന്റെ വിശ്വാസ്യതയും സ്ഥിരതയും ഉറപ്പാക്കേണ്ടത് അത്യാവശ്യമാണ്. ജാവാസ്ക്രിപ്റ്റ് ടെസ്റ്റിംഗിന്റെ ഒരു മാനദണ്ഡമായി ജെസ്റ്റ് മാറിയിട്ടുണ്ടെങ്കിലും, അടിസ്ഥാന യൂണിറ്റ് ടെസ്റ്റുകൾക്കപ്പുറത്തേക്ക് പോകുന്നത് നിങ്ങളുടെ ആപ്ലിക്കേഷനുകളിൽ ഒരു പുതിയ തലത്തിലുള്ള ആത്മവിശ്വാസം നൽകുന്നു. ഈ പോസ്റ്റ് കരുത്തുറ്റ സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുന്നതിന് അത്യന്താപേക്ഷിതമായ, ആഗോളതലത്തിലുള്ള ഡെവലപ്പർമാർക്ക് വേണ്ടിയുള്ള നൂതന ജെസ്റ്റ് ടെസ്റ്റിംഗ് പാറ്റേണുകളിലേക്ക് ആഴത്തിൽ ഇറങ്ങിച്ചെല്ലുന്നു.

എന്തിന് അടിസ്ഥാന യൂണിറ്റ് ടെസ്റ്റുകൾക്കപ്പുറം പോകണം?

അടിസ്ഥാന യൂണിറ്റ് ടെസ്റ്റുകൾ ഓരോ ഘടകങ്ങളെയും ഒറ്റയ്ക്ക് പരിശോധിക്കുന്നു. എന്നാൽ, യഥാർത്ഥ ലോകത്തിലെ ആപ്ലിക്കേഷനുകൾ ഘടകങ്ങൾ പരസ്പരം സംവദിക്കുന്ന സങ്കീർണ്ണമായ സിസ്റ്റങ്ങളാണ്. നൂതന ടെസ്റ്റിംഗ് പാറ്റേണുകൾ ഈ സങ്കീർണ്ണതകളെ അഭിസംബോധന ചെയ്യുന്നത് നമ്മെ ഇനിപ്പറയുന്നവയ്ക്ക് പ്രാപ്തരാക്കിക്കൊണ്ടാണ്:

• സങ്കീർണ്ണമായ ഡിപൻഡൻസികളെ അനുകരിക്കുക.
• യുഐ മാറ്റങ്ങൾ വിശ്വസനീയമായി കണ്ടെത്തുക.
• കൂടുതൽ വ്യക്തവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ടെസ്റ്റുകൾ എഴുതുക.
• ഇന്റഗ്രേഷൻ പോയിന്റുകളിൽ ടെസ്റ്റ് കവറേജും ആത്മവിശ്വാസവും മെച്ചപ്പെടുത്തുക.
• ടെസ്റ്റ്-ഡ്രിവൺ ഡെവലപ്‌മെന്റ് (TDD), ബിഹേവിയർ-ഡ്രിവൺ ഡെവലപ്‌മെന്റ് (BDD) വർക്ക്ഫ്ലോകളെ സുഗമമാക്കുക.

മോക്കിംഗിലും സ്പൈസിലും വൈദഗ്ദ്ധ്യം നേടുന്നു

ടെസ്റ്റ് ചെയ്യേണ്ട യൂണിറ്റിനെ അതിന്റെ ഡിപൻഡൻസികൾക്ക് പകരം നിയന്ത്രിത പകരക്കാരെ വെച്ച് ഒറ്റപ്പെടുത്തുന്നതിന് മോക്കിംഗ് നിർണ്ണായകമാണ്. ഇതിനായി ജെസ്റ്റ് ശക്തമായ ടൂളുകൾ നൽകുന്നു:

jest.fn(): മോക്കുകളുടെയും സ്പൈസിന്റെയും അടിസ്ഥാനം

jest.fn() ഒരു മോക്ക് ഫംഗ്ഷൻ ഉണ്ടാക്കുന്നു. നിങ്ങൾക്ക് അതിന്റെ കോളുകൾ, ആർഗ്യുമെന്റുകൾ, റിട്ടേൺ മൂല്യങ്ങൾ എന്നിവ ട്രാക്ക് ചെയ്യാൻ കഴിയും. കൂടുതൽ സങ്കീർണ്ണമായ മോക്കിംഗ് തന്ത്രങ്ങൾക്കുള്ള അടിസ്ഥാന ഘടകമാണിത്.

ഉദാഹരണം: ഫംഗ്ഷൻ കോളുകൾ ട്രാക്ക് ചെയ്യുന്നു

// component.js
export const fetchData = () => {
  // ഒരു API കോളിനെ അനുകരിക്കുന്നു
  return Promise.resolve({ data: 'some data' });
};

export const processData = async (fetcher) => {
  const result = await fetcher();
  return `Processed: ${result.data}`;
};

// component.test.js
import { processData } from './component';

test('ഡാറ്റ ശരിയായി പ്രോസസ്സ് ചെയ്യണം', async () => {
  const mockFetcher = jest.fn().mockResolvedValue({ data: 'mocked data' });
  const result = await processData(mockFetcher);
  expect(result).toBe('Processed: mocked data');
  expect(mockFetcher).toHaveBeenCalledTimes(1);
  expect(mockFetcher).toHaveBeenCalledWith();
});

jest.spyOn(): മാറ്റിസ്ഥാപിക്കാതെ നിരീക്ഷിക്കുന്നു

jest.spyOn() ഒരു നിലവിലുള്ള ഒബ്ജക്റ്റിലെ മെത്തേഡിലേക്കുള്ള കോളുകൾ അതിന്റെ പ്രവർത്തനം മാറ്റിവെക്കാതെ തന്നെ നിരീക്ഷിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ആവശ്യമെങ്കിൽ നിങ്ങൾക്ക് അതിന്റെ പ്രവർത്തനം മോക്ക് ചെയ്യാനും കഴിയും.

ഉദാഹരണം: ഒരു മൊഡ്യൂൾ മെത്തേഡിൽ സ്പൈ ചെയ്യുന്നു

// logger.js
export const logInfo = (message) => {
  console.log(`INFO: ${message}`);
};

// service.js
import { logInfo } from './logger';

export const performTask = (taskName) => {
  logInfo(`Starting task: ${taskName}`);
  // ... ടാസ്ക് ലോജിക് ...
  logInfo(`Task ${taskName} completed.`);
};

// service.test.js
import { performTask } from './service';
import * as logger from './logger';

test('ടാസ്ക് ആരംഭവും പൂർത്തീകരണവും ലോഗ് ചെയ്യണം', () => {
  const logSpy = jest.spyOn(logger, 'logInfo');

  performTask('backup');

  expect(logSpy).toHaveBeenCalledTimes(2);
  expect(logSpy).toHaveBeenCalledWith('Starting task: backup');
  expect(logSpy).toHaveBeenCalledWith('Task backup completed.');

  logSpy.mockRestore(); // യഥാർത്ഥ പ്രവർത്തനം പുനഃസ്ഥാപിക്കേണ്ടത് പ്രധാനമാണ്
});

മൊഡ്യൂൾ ഇംപോർട്ടുകൾ മോക്ക് ചെയ്യുന്നു

ജെസ്റ്റിന്റെ മൊഡ്യൂൾ മോക്കിംഗ് കഴിവുകൾ വിപുലമാണ്. നിങ്ങൾക്ക് മുഴുവൻ മൊഡ്യൂളുകളെയോ അല്ലെങ്കിൽ പ്രത്യേക എക്സ്പോർട്ടുകളെയോ മോക്ക് ചെയ്യാൻ കഴിയും.

ഉദാഹരണം: ഒരു എക്സ്റ്റേണൽ API ക്ലയിന്റ് മോക്ക് ചെയ്യുന്നു

// api.js
import axios from 'axios';

export const getUser = async (userId) => {
  const response = await axios.get(`/api/users/${userId}`);
  return response.data;
};

// user-service.js
import { getUser } from './api';

export const getUserFullName = async (userId) => {
  const user = await getUser(userId);
  return `${user.firstName} ${user.lastName}`;
};

// user-service.test.js
import { getUserFullName } from './user-service';
import * as api from './api';

// മുഴുവൻ api മൊഡ്യൂളും മോക്ക് ചെയ്യുക
jest.mock('./api');

test('മോക്ക് ചെയ്ത API ഉപയോഗിച്ച് മുഴുവൻ പേരും ലഭിക്കണം', async () => {
  // മോക്ക് ചെയ്ത മൊഡ്യൂളിൽ നിന്ന് പ്രത്യേക ഫംഗ്ഷൻ മോക്ക് ചെയ്യുക
  api.getUser.mockResolvedValue({ id: 1, firstName: 'Ada', lastName: 'Lovelace' });

  const fullName = await getUserFullName(1);

  expect(fullName).toBe('Ada Lovelace');
  expect(api.getUser).toHaveBeenCalledTimes(1);
  expect(api.getUser).toHaveBeenCalledWith(1);
});

ഓട്ടോ-മോക്കിംഗ് vs. മാനുവൽ മോക്കിംഗ്

ജെസ്റ്റ് Node.js മൊഡ്യൂളുകളെ യാന്ത്രികമായി മോക്ക് ചെയ്യുന്നു. ES മൊഡ്യൂളുകൾക്കോ ​​കസ്റ്റം മൊഡ്യൂളുകൾക്കോ, നിങ്ങൾക്ക് jest.mock() ആവശ്യമായി വന്നേക്കാം. കൂടുതൽ നിയന്ത്രണത്തിനായി, നിങ്ങൾക്ക് __mocks__ ഡയറക്ടറികൾ ഉണ്ടാക്കാം.

മോക്ക് ഇംപ്ലിമെന്റേഷനുകൾ

നിങ്ങളുടെ മോക്കുകൾക്കായി നിങ്ങൾക്ക് കസ്റ്റം ഇംപ്ലിമെന്റേഷനുകൾ നൽകാം.

ഉദാഹരണം: ഒരു കസ്റ്റം ഇംപ്ലിമെന്റേഷൻ ഉപയോഗിച്ച് മോക്ക് ചെയ്യുന്നു

// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// calculator.js
import { add, subtract } from './math';

export const calculate = (operation, a, b) => {
  if (operation === 'add') {
    return add(a, b);
  } else if (operation === 'subtract') {
    return subtract(a, b);
  }
  return null;
};

// calculator.test.js
import { calculate } from './calculator';
import * as math from './math';

// മുഴുവൻ math മൊഡ്യൂളും മോക്ക് ചെയ്യുക
jest.mock('./math');

test('മോക്ക് ചെയ്ത math add ഉപയോഗിച്ച് സങ്കലനം നടത്തണം', () => {
  // 'add' ഫംഗ്ഷനായി ഒരു മോക്ക് ഇംപ്ലിമെന്റേഷൻ നൽകുക
  math.add.mockImplementation((a, b) => a + b + 10); // ഫലത്തിൽ 10 ചേർക്കുക
  math.subtract.mockReturnValue(5); // subtract-നെയും മോക്ക് ചെയ്യുക

  const result = calculate('add', 5, 3);

  expect(math.add).toHaveBeenCalledWith(5, 3);
  expect(result).toBe(18); // 5 + 3 + 10

  const subResult = calculate('subtract', 10, 2);
  expect(math.subtract).toHaveBeenCalledWith(10, 2);
  expect(subResult).toBe(5);
});

സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റിംഗ്: യുഐയും കോൺഫിഗറേഷനും സംരക്ഷിക്കുന്നു

നിങ്ങളുടെ കംപോണന്റുകളുടെയോ കോൺഫിഗറേഷനുകളുടെയോ ഔട്ട്പുട്ട് പിടിച്ചെടുക്കുന്നതിനുള്ള ശക്തമായ ഒരു ഫീച്ചറാണ് സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റുകൾ. യുഐ ടെസ്റ്റിംഗിനോ സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകൾ പരിശോധിക്കുന്നതിനോ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റിംഗ് എങ്ങനെ പ്രവർത്തിക്കുന്നു

ആദ്യമായി ഒരു സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റ് പ്രവർത്തിക്കുമ്പോൾ, ജെസ്റ്റ് ടെസ്റ്റ് ചെയ്ത മൂല്യത്തിന്റെ ഒരു സീരിയലൈസ് ചെയ്ത രൂപം അടങ്ങിയ ഒരു .snap ഫയൽ ഉണ്ടാക്കുന്നു. തുടർന്നുള്ള റണ്ണുകളിൽ, ജെസ്റ്റ് നിലവിലെ ഔട്ട്പുട്ടിനെ സംഭരിച്ച സ്നാപ്പ്ഷോട്ടുമായി താരതമ്യം ചെയ്യുന്നു. അവ വ്യത്യാസപ്പെട്ടിട്ടുണ്ടെങ്കിൽ, ടെസ്റ്റ് പരാജയപ്പെടും, ഇത് ഉദ്ദേശിക്കാത്ത മാറ്റങ്ങളെക്കുറിച്ച് നിങ്ങളെ അറിയിക്കുന്നു. വിവിധ പ്രദേശങ്ങളിലോ ഭാഷകളിലോ ഉള്ള യുഐ കംപോണന്റുകളിലെ പിഴവുകൾ കണ്ടെത്താൻ ഇത് അമൂല്യമാണ്.

ഉദാഹരണം: ഒരു റിയാക്റ്റ് കംപോണന്റിന്റെ സ്നാപ്പ്ഷോട്ട് എടുക്കുന്നു

നിങ്ങൾക്ക് ഒരു റിയാക്റ്റ് കംപോണന്റ് ഉണ്ടെന്ന് കരുതുക:

// UserProfile.js
import React from 'react';

const UserProfile = ({ name, email, isActive }) => (
  <div>
    <h2>{name}</h2>
    <p><strong>Email:</strong> {email}</p>
    <p><strong>Status:</strong> {isActive ? 'Active' : 'Inactive'}</p>
  </div>
);

export default UserProfile;

// UserProfile.test.js
import React from 'react';
import renderer from 'react-test-renderer'; // റിയാക്റ്റ് കംപോണന്റ് സ്നാപ്പ്ഷോട്ടുകൾക്കായി
import UserProfile from './UserProfile';

test('UserProfile ശരിയായി റെൻഡർ ചെയ്യുന്നു', () => {
  const user = {
    name: 'Jane Doe',
    email: 'jane.doe@example.com',
    isActive: true,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot();
});

test('നിർജ്ജീവമായ UserProfile ശരിയായി റെൻഡർ ചെയ്യുന്നു', () => {
  const user = {
    name: 'John Smith',
    email: 'john.smith@example.com',
    isActive: false,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot('inactive user profile'); // പേരുള്ള സ്നാപ്പ്ഷോട്ട്
});

ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിച്ച ശേഷം, ജെസ്റ്റ് ഒരു UserProfile.test.js.snap ഫയൽ ഉണ്ടാക്കും. നിങ്ങൾ കംപോണന്റ് അപ്ഡേറ്റ് ചെയ്യുമ്പോൾ, മാറ്റങ്ങൾ അവലോകനം ചെയ്യുകയും --updateSnapshot അല്ലെങ്കിൽ -u ഫ്ലാഗ് ഉപയോഗിച്ച് ജെസ്റ്റ് പ്രവർത്തിപ്പിച്ച് സ്നാപ്പ്ഷോട്ട് അപ്ഡേറ്റ് ചെയ്യേണ്ടിയും വന്നേക്കാം.

സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റിംഗിനുള്ള മികച്ച രീതികൾ

• യുഐ കംപോണന്റുകൾക്കും കോൺഫിഗറേഷൻ ഫയലുകൾക്കും ഉപയോഗിക്കുക: യുഐ ഘടകങ്ങൾ പ്രതീക്ഷിച്ചതുപോലെ റെൻഡർ ചെയ്യുന്നുവെന്നും കോൺഫിഗറേഷൻ അപ്രതീക്ഷിതമായി മാറുന്നില്ലെന്നും ഉറപ്പാക്കാൻ അനുയോജ്യം.
• സ്നാപ്പ്ഷോട്ടുകൾ ശ്രദ്ധാപൂർവ്വം അവലോകനം ചെയ്യുക: സ്നാപ്പ്ഷോട്ട് അപ്ഡേറ്റുകൾ അന്ധമായി അംഗീകരിക്കരുത്. മാറ്റങ്ങൾ മനഃപൂർവമാണെന്ന് ഉറപ്പാക്കാൻ എന്താണ് മാറിയതെന്ന് എപ്പോഴും അവലോകനം ചെയ്യുക.
• പതിവായി മാറുന്ന ഡാറ്റയ്ക്കായി സ്നാപ്പ്ഷോട്ടുകൾ ഒഴിവാക്കുക: ഡാറ്റ വേഗത്തിൽ മാറുകയാണെങ്കിൽ, സ്നാപ്പ്ഷോട്ടുകൾ ദുർബലമാവുകയും അനാവശ്യമായ ബഹളത്തിന് കാരണമാവുകയും ചെയ്യും.
• പേരുള്ള സ്നാപ്പ്ഷോട്ടുകൾ ഉപയോഗിക്കുക: ഒരു കംപോണന്റിന്റെ ഒന്നിലധികം അവസ്ഥകൾ പരീക്ഷിക്കുന്നതിന്, പേരുള്ള സ്നാപ്പ്ഷോട്ടുകൾ കൂടുതൽ വ്യക്തത നൽകുന്നു.

കസ്റ്റം മാച്ചറുകൾ: ടെസ്റ്റിന്റെ വായനാക്ഷമത വർദ്ധിപ്പിക്കുന്നു

ജെസ്റ്റിന്റെ ബിൽറ്റ്-ഇൻ മാച്ചറുകൾ വിപുലമാണ്, എന്നാൽ ചിലപ്പോൾ നിങ്ങൾക്ക് ഉൾക്കൊള്ളാത്ത പ്രത്യേക വ്യവസ്ഥകൾ ഉറപ്പാക്കേണ്ടിവരും. കസ്റ്റം മാച്ചറുകൾ നിങ്ങളുടെ സ്വന്തം അസേർഷൻ ലോജിക് ഉണ്ടാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് നിങ്ങളുടെ ടെസ്റ്റുകളെ കൂടുതൽ പ്രകടവും വായനാക്ഷമവുമാക്കുന്നു.

കസ്റ്റം മാച്ചറുകൾ ഉണ്ടാക്കുന്നു

നിങ്ങളുടെ സ്വന്തം മാച്ചറുകൾ ഉപയോഗിച്ച് ജെസ്റ്റിന്റെ expect ഒബ്ജക്റ്റ് വികസിപ്പിക്കാൻ നിങ്ങൾക്ക് കഴിയും.

ഉദാഹരണം: ഒരു സാധുവായ ഇമെയിൽ ഫോർമാറ്റ് പരിശോധിക്കുന്നു

നിങ്ങളുടെ ജെസ്റ്റ് സെറ്റപ്പ് ഫയലിൽ (ഉദാഹരണത്തിന്, jest.setup.js, jest.config.js ൽ കോൺഫിഗർ ചെയ്തത്):

// jest.setup.js

expect.extend({
  toBeValidEmail(received) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    const pass = emailRegex.test(received);

    if (pass) {
      return {
        message: () => `expected ${received} not to be a valid email`,
        pass: true,
      };
    } else {
      return {
        message: () => `expected ${received} to be a valid email`,
        pass: false,
      };
    }
  },
});

// നിങ്ങളുടെ jest.config.js-ൽ
// module.exports = { setupFilesAfterEnv: ['/jest.setup.js'] };

നിങ്ങളുടെ ടെസ്റ്റ് ഫയലിൽ:

// validation.test.js

test('ഇമെയിൽ ഫോർമാറ്റുകൾ സാധൂകരിക്കണം', () => {
  expect('test@example.com').toBeValidEmail();
  expect('invalid-email').not.toBeValidEmail();
  expect('another.test@sub.domain.co.uk').toBeValidEmail();
});

കസ്റ്റം മാച്ചറുകളുടെ പ്രയോജനങ്ങൾ

• മെച്ചപ്പെട്ട വായനാക്ഷമത: ടെസ്റ്റുകൾ *എങ്ങനെ* എന്നതിനേക്കാൾ *എന്താണ്* പരീക്ഷിക്കുന്നത് എന്ന് പ്രസ്താവിക്കുന്ന, കൂടുതൽ പ്രഖ്യാപനപരമായി മാറുന്നു.
• കോഡ് പുനരുപയോഗം: ഒന്നിലധികം ടെസ്റ്റുകളിൽ സങ്കീർണ്ണമായ അസേർഷൻ ലോജിക് ആവർത്തിക്കുന്നത് ഒഴിവാക്കുക.
• ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട അസേർഷനുകൾ: നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ പ്രത്യേക ഡൊമെയ്ൻ ആവശ്യകതകൾക്ക് അനുസരിച്ച് അസേർഷനുകൾ ക്രമീകരിക്കുക.

അസിൻക്രണസ് ഓപ്പറേഷനുകൾ ടെസ്റ്റ് ചെയ്യുന്നു

ജാവാസ്ക്രിപ്റ്റ് വളരെയധികം അസിൻക്രണസ് ആണ്. പ്രോമിസുകളും async/await-ഉം ടെസ്റ്റ് ചെയ്യുന്നതിന് ജെസ്റ്റ് മികച്ച പിന്തുണ നൽകുന്നു.

async/await ഉപയോഗിക്കുന്നു

അസിൻക്രണസ് കോഡ് ടെസ്റ്റ് ചെയ്യുന്നതിനുള്ള ആധുനികവും ഏറ്റവും വായനാക്ഷമവുമായ മാർഗ്ഗമാണിത്.

ഉദാഹരണം: ഒരു അസിൻക്രണസ് ഫംഗ്ഷൻ ടെസ്റ്റ് ചെയ്യുന്നു

// dataService.js
export const fetchUserData = async (userId) => {
  // ഒരു കാലതാമസത്തിന് ശേഷം ഡാറ്റ ലഭ്യമാക്കുന്നത് അനുകരിക്കുന്നു
  await new Promise(resolve => setTimeout(resolve, 50));
  if (userId === 1) {
    return { id: 1, name: 'Alice' };
  } else {
    throw new Error('User not found');
  }
};

// dataService.test.js
import { fetchUserData } from './dataService';

test('ഉപയോക്തൃ ഡാറ്റ ശരിയായി ലഭ്യമാക്കുന്നു', async () => {
  const user = await fetchUserData(1);
  expect(user).toEqual({ id: 1, name: 'Alice' });
});

test('നിലവിലില്ലാത്ത ഉപയോക്താവിനായി പിശക് നൽകുന്നു', async () => {
  await expect(fetchUserData(2)).rejects.toThrow('User not found');
});

.resolves-ഉം .rejects-ഉം ഉപയോഗിക്കുന്നു

ഈ മാച്ചറുകൾ പ്രോമിസ് റെസല്യൂഷനുകളും റിജക്ഷനുകളും ടെസ്റ്റ് ചെയ്യുന്നത് ലളിതമാക്കുന്നു.

ഉദാഹരണം: .resolves/.rejects ഉപയോഗിക്കുന്നു

// dataService.test.js (തുടർച്ച)

test('.resolves ഉപയോഗിച്ച് ഉപയോക്തൃ ഡാറ്റ ലഭ്യമാക്കുന്നു', () => {
  return expect(fetchUserData(1)).resolves.toEqual({ id: 1, name: 'Alice' });
});

test('.rejects ഉപയോഗിച്ച് നിലവിലില്ലാത്ത ഉപയോക്താവിനായി പിശക് നൽകുന്നു', () => {
  return expect(fetchUserData(2)).rejects.toThrow('User not found');
});

ടൈമറുകൾ കൈകാര്യം ചെയ്യുന്നു

setTimeout അല്ലെങ്കിൽ setInterval ഉപയോഗിക്കുന്ന ഫംഗ്ഷനുകൾക്കായി, ജെസ്റ്റ് ടൈമർ നിയന്ത്രണം നൽകുന്നു.

ഉദാഹരണം: ടൈമറുകൾ നിയന്ത്രിക്കുന്നു

// delayedGreeter.js
export const greetAfterDelay = (name, callback) => {
  setTimeout(() => {
    callback(`Hello, ${name}!`);
  }, 1000);
};

// delayedGreeter.test.js
import { greetAfterDelay } from './delayedGreeter';

jest.useFakeTimers(); // വ്യാജ ടൈമറുകൾ പ്രവർത്തനക്ഷമമാക്കുക

test('കാലതാമസത്തിന് ശേഷം അഭിവാദ്യം ചെയ്യുന്നു', () => {
  const mockCallback = jest.fn();
  greetAfterDelay('World', mockCallback);

  // ടൈമറുകൾ 1000ms മുന്നോട്ട് നീക്കുക
  jest.advanceTimersByTime(1000);

  expect(mockCallback).toHaveBeenCalledTimes(1);
  expect(mockCallback).toHaveBeenCalledWith('Hello, World!');
});

// മറ്റെവിടെയെങ്കിലും ആവശ്യമെങ്കിൽ യഥാർത്ഥ ടൈമറുകൾ പുനഃസ്ഥാപിക്കുക
jest.useRealTimers();

ടെസ്റ്റിന്റെ ഓർഗനൈസേഷനും ഘടനയും

നിങ്ങളുടെ ടെസ്റ്റ് സ്യൂട്ട് വളരുമ്പോൾ, പരിപാലനക്ഷമതയ്ക്ക് ഓർഗനൈസേഷൻ നിർണ്ണായകമാകും.

ഡിസ്ക്രൈബ് ബ്ലോക്കുകളും ഇറ്റ് ബ്ലോക്കുകളും

ബന്ധപ്പെട്ട ടെസ്റ്റുകളെ ഗ്രൂപ്പുചെയ്യാൻ describe-ഉം വ്യക്തിഗത ടെസ്റ്റ് കേസുകൾക്കായി it (അല്ലെങ്കിൽ test)-ഉം ഉപയോഗിക്കുക. ഈ ഘടന ആപ്ലിക്കേഷന്റെ മോഡുലാരിറ്റിയെ പ്രതിഫലിപ്പിക്കുന്നു.

ഉദാഹരണം: ഘടനാപരമായ ടെസ്റ്റുകൾ

describe('ഉപയോക്തൃ ഓതന്റിക്കേഷൻ സേവനം', () => {
  let authService;

  beforeEach(() => {
    // ഓരോ ടെസ്റ്റിനും മുമ്പായി മോക്കുകളോ സേവന ഇൻസ്റ്റൻസുകളോ സജ്ജമാക്കുക
    authService = require('./authService');
    jest.spyOn(authService, 'login').mockImplementation(() => Promise.resolve({ token: 'fake_token' }));
  });

  afterEach(() => {
    // മോക്കുകൾ വൃത്തിയാക്കുക
    jest.restoreAllMocks();
  });

  describe('ലോഗിൻ പ്രവർത്തനം', () => {
    it('സാധുവായ ക്രെഡൻഷ്യലുകളുള്ള ഒരു ഉപയോക്താവിനെ വിജയകരമായി ലോഗിൻ ചെയ്യണം', async () => {
      const result = await authService.login('user@example.com', 'password123');
      expect(result.token).toBeDefined();
      // ... കൂടുതൽ അസേർഷനുകൾ ...
    });

    it('അസാധുവായ ക്രെഡൻഷ്യലുകളുള്ള ലോഗിൻ പരാജയപ്പെടണം', async () => {
      jest.spyOn(authService, 'login').mockRejectedValue(new Error('Invalid credentials'));
      await expect(authService.login('user@example.com', 'wrong_password')).rejects.toThrow('Invalid credentials');
    });
  });

  describe('ലോഗൗട്ട് പ്രവർത്തനം', () => {
    it('ഉപയോക്തൃ സെഷൻ മായ്ച്ചുകളയണം', async () => {
      // ലോഗൗട്ട് ലോജിക് പരീക്ഷിക്കുക...
    });
  });
});

സെറ്റപ്പ്, ടിയർഡൗൺ ഹുക്കുകൾ

• beforeAll: ഒരു describe ബ്ലോക്കിലെ എല്ലാ ടെസ്റ്റുകൾക്കും മുമ്പ് ഒരു തവണ പ്രവർത്തിക്കുന്നു.
• afterAll: ഒരു describe ബ്ലോക്കിലെ എല്ലാ ടെസ്റ്റുകൾക്കും ശേഷം ഒരു തവണ പ്രവർത്തിക്കുന്നു.
• beforeEach: ഒരു describe ബ്ലോക്കിലെ ഓരോ ടെസ്റ്റിനും മുമ്പ് പ്രവർത്തിക്കുന്നു.
• afterEach: ഒരു describe ബ്ലോക്കിലെ ഓരോ ടെസ്റ്റിനും ശേഷം പ്രവർത്തിക്കുന്നു.

മോക്ക് ഡാറ്റ, ഡാറ്റാബേസ് കണക്ഷനുകൾ സജ്ജീകരിക്കുന്നതിനോ അല്ലെങ്കിൽ ടെസ്റ്റുകൾക്കിടയിൽ റിസോഴ്സുകൾ വൃത്തിയാക്കുന്നതിനോ ഈ ഹുക്കുകൾ അത്യാവശ്യമാണ്.

ആഗോള പ്രേക്ഷകർക്കായി ടെസ്റ്റ് ചെയ്യുന്നു

ഒരു ആഗോള പ്രേക്ഷകർക്കായി ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുമ്പോൾ, ടെസ്റ്റിംഗ് പരിഗണനകൾ വികസിക്കുന്നു:

അന്താരാഷ്ട്രവൽക്കരണം (i18n), പ്രാദേശികവൽക്കരണം (l10n)

നിങ്ങളുടെ യുഐയും സന്ദേശങ്ങളും വിവിധ ഭാഷകൾക്കും പ്രാദേശിക ഫോർമാറ്റുകൾക്കും ശരിയായി പൊരുത്തപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കുക.

• പ്രാദേശികവൽക്കരിച്ച യുഐയുടെ സ്നാപ്പ്ഷോട്ട് എടുക്കൽ: സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ യുഐയുടെ വിവിധ ഭാഷാ പതിപ്പുകൾ ശരിയായി റെൻഡർ ചെയ്യുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക.
• ലോക്കേൽ ഡാറ്റ മോക്ക് ചെയ്യൽ: വിവിധ ലോക്കേൽ സന്ദേശങ്ങൾ ഉപയോഗിച്ച് കംപോണന്റ് സ്വഭാവം പരീക്ഷിക്കാൻ react-intl അല്ലെങ്കിൽ i18next പോലുള്ള ലൈബ്രറികളെ മോക്ക് ചെയ്യുക.
• തീയതി, സമയം, കറൻസി ഫോർമാറ്റിംഗ്: കസ്റ്റം മാച്ചറുകൾ ഉപയോഗിച്ചോ അന്താരാഷ്ട്രവൽക്കരണ ലൈബ്രറികൾ മോക്ക് ചെയ്തോ ഇവ ശരിയായി കൈകാര്യം ചെയ്യുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക. ഉദാഹരണത്തിന്, ജർമ്മനിക്ക് (DD.MM.YYYY) ഫോർമാറ്റ് ചെയ്ത തീയതി യുഎസ്സിനുള്ളതിൽ (MM/DD/YYYY) നിന്ന് വ്യത്യസ്തമായി കാണപ്പെടുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്നു.

ഉദാഹരണം: പ്രാദേശികവൽക്കരിച്ച തീയതി ഫോർമാറ്റിംഗ് പരീക്ഷിക്കുന്നു

// dateUtils.js
export const formatLocalizedDate = (date, locale) => {
  return new Intl.DateTimeFormat(locale, { year: 'numeric', month: 'numeric', day: 'numeric' }).format(date);
};

// dateUtils.test.js
import { formatLocalizedDate } from './dateUtils';

test('യുഎസ് ലോക്കേലിനായി തീയതി ശരിയായി ഫോർമാറ്റ് ചെയ്യുന്നു', () => {
  const date = new Date(2023, 10, 15); // നവംബർ 15, 2023
  expect(formatLocalizedDate(date, 'en-US')).toBe('11/15/2023');
});

test('ജർമ്മൻ ലോക്കേലിനായി തീയതി ശരിയായി ഫോർമാറ്റ് ചെയ്യുന്നു', () => {
  const date = new Date(2023, 10, 15);
  expect(formatLocalizedDate(date, 'de-DE')).toBe('15.11.2023');
});

സമയ മേഖലയെക്കുറിച്ചുള്ള അവബോധം

ഷെഡ്യൂളിംഗ് അല്ലെങ്കിൽ തത്സമയ അപ്‌ഡേറ്റുകൾ പോലുള്ള ഫീച്ചറുകൾക്കായി നിങ്ങളുടെ ആപ്ലിക്കേഷൻ വിവിധ സമയ മേഖലകളെ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നുവെന്ന് പരിശോധിക്കുക. സിസ്റ്റം ക്ലോക്ക് മോക്ക് ചെയ്യുകയോ സമയ മേഖലകളെ വേർതിരിക്കുന്ന ലൈബ്രറികൾ ഉപയോഗിക്കുകയോ ചെയ്യുന്നത് പ്രയോജനകരമാണ്.

ഡാറ്റയിലെ സാംസ്കാരിക സൂക്ഷ്മതകൾ

അക്കങ്ങൾ, കറൻസികൾ, മറ്റ് ഡാറ്റാ പ്രാതിനിധ്യങ്ങൾ എന്നിവ സംസ്കാരങ്ങൾക്കിടയിൽ എങ്ങനെ വ്യത്യസ്തമായി കാണപ്പെടുകയോ പ്രതീക്ഷിക്കുകയോ ചെയ്യാം എന്ന് പരിഗണിക്കുക. കസ്റ്റം മാച്ചറുകൾ ഇവിടെ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും.

നൂതന ടെക്നിക്കുകളും തന്ത്രങ്ങളും

ടെസ്റ്റ്-ഡ്രിവൺ ഡെവലപ്‌മെന്റ് (TDD), ബിഹേവിയർ-ഡ്രിവൺ ഡെവലപ്‌മെന്റ് (BDD)

ജെസ്റ്റ് TDD (റെഡ്-ഗ്രീൻ-റിഫാക്ടർ), BDD (ഗിവൺ-വെൻ-ദെൻ) രീതിശാസ്ത്രങ്ങളുമായി നന്നായി യോജിക്കുന്നു. ഇംപ്ലിമെന്റേഷൻ കോഡ് എഴുതുന്നതിനുമുമ്പ് ആഗ്രഹിക്കുന്ന സ്വഭാവം വിവരിക്കുന്ന ടെസ്റ്റുകൾ എഴുതുക. ഇത് തുടക്കം മുതൽ തന്നെ ടെസ്റ്റബിലിറ്റി മനസ്സിൽ വെച്ചാണ് കോഡ് എഴുതുന്നതെന്ന് ഉറപ്പാക്കുന്നു.

ജെസ്റ്റ് ഉപയോഗിച്ചുള്ള ഇന്റഗ്രേഷൻ ടെസ്റ്റിംഗ്

യൂണിറ്റ് ടെസ്റ്റുകളിൽ ജെസ്റ്റ് മികച്ചുനിൽക്കുമ്പോൾ, ഇന്റഗ്രേഷൻ ടെസ്റ്റുകൾക്കായും ഇത് ഉപയോഗിക്കാം. കുറഞ്ഞ ഡിപൻഡൻസികൾ മോക്ക് ചെയ്യുകയോ അല്ലെങ്കിൽ ജെസ്റ്റിന്റെ runInBand ഓപ്ഷൻ പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കുകയോ ചെയ്യുന്നത് സഹായിക്കും.

ഉദാഹരണം: API ഇന്ററാക്ഷൻ ടെസ്റ്റ് ചെയ്യുന്നു (ലളിതമാക്കിയത്)

// apiService.js
import axios from 'axios';

const API_BASE_URL = 'https://api.example.com';

export const createProduct = async (productData) => {
  const response = await axios.post(`${API_BASE_URL}/products`, productData);
  return response.data;
};

// apiService.test.js (ഇന്റഗ്രേഷൻ ടെസ്റ്റ്)
import axios from 'axios';
import { createProduct } from './apiService';

// നെറ്റ്വർക്ക് ലെയർ നിയന്ത്രിക്കുന്നതിന് ഇന്റഗ്രേഷൻ ടെസ്റ്റുകൾക്കായി axios മോക്ക് ചെയ്യുക
jest.mock('axios');

test('API വഴി ഒരു ഉൽപ്പന്നം ഉണ്ടാക്കുന്നു', async () => {
  const mockProduct = { id: 1, name: 'Gadget' };
  const responseData = { success: true, product: mockProduct };

  axios.post.mockResolvedValue({
    data: responseData,
    status: 201,
    headers: { 'content-type': 'application/json' },
  });

  const newProductData = { name: 'Gadget', price: 99.99 };
  const result = await createProduct(newProductData);

  expect(axios.post).toHaveBeenCalledWith(`${process.env.API_BASE_URL || 'https://api.example.com'}/products`, newProductData);
  expect(result).toEqual(responseData);
});

സമാന്തരതയും കോൺഫിഗറേഷനും

നിർവ്വഹണം വേഗത്തിലാക്കാൻ ജെസ്റ്റിന് സമാന്തരമായി ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും. ഇത് നിങ്ങളുടെ jest.config.js-ൽ കോൺഫിഗർ ചെയ്യുക. ഉദാഹരണത്തിന്, maxWorkers ക്രമീകരിക്കുന്നത് സമാന്തര പ്രോസസ്സുകളുടെ എണ്ണം നിയന്ത്രിക്കുന്നു.

കവറേജ് റിപ്പോർട്ടുകൾ

നിങ്ങളുടെ കോഡ്‌ബേസിന്റെ പരീക്ഷിക്കാത്ത ഭാഗങ്ങൾ തിരിച്ചറിയാൻ ജെസ്റ്റിന്റെ ബിൽറ്റ്-ഇൻ കവറേജ് റിപ്പോർട്ടിംഗ് ഉപയോഗിക്കുക. വിശദമായ റിപ്പോർട്ടുകൾ ഉണ്ടാക്കാൻ --coverage ഉപയോഗിച്ച് ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക.

jest --coverage

കവറേജ് റിപ്പോർട്ടുകൾ അവലോകനം ചെയ്യുന്നത്, അന്താരാഷ്ട്രവൽക്കരണവും പ്രാദേശികവൽക്കരണ കോഡ് പാതകളും ഉൾപ്പെടെ, നിങ്ങളുടെ നൂതന ടെസ്റ്റിംഗ് പാറ്റേണുകൾ നിർണ്ണായക ലോജിക്കിനെ ഫലപ്രദമായി കവർ ചെയ്യുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ സഹായിക്കുന്നു.

ഉപസംഹാരം

നൂതന ജെസ്റ്റ് ടെസ്റ്റിംഗ് പാറ്റേണുകളിൽ വൈദഗ്ദ്ധ്യം നേടുന്നത് ഒരു ആഗോള പ്രേക്ഷകർക്കായി വിശ്വസനീയവും, പരിപാലിക്കാൻ എളുപ്പമുള്ളതും, ഉയർന്ന നിലവാരമുള്ളതുമായ സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുന്നതിനുള്ള ഒരു പ്രധാന ചുവടുവെപ്പാണ്. മോക്കിംഗ്, സ്നാപ്പ്ഷോട്ട് ടെസ്റ്റിംഗ്, കസ്റ്റം മാച്ചറുകൾ, അസിൻക്രണസ് ടെസ്റ്റിംഗ് ടെക്നിക്കുകൾ എന്നിവ ഫലപ്രദമായി ഉപയോഗിക്കുന്നതിലൂടെ, നിങ്ങളുടെ ടെസ്റ്റ് സ്യൂട്ടിന്റെ കരുത്ത് വർദ്ധിപ്പിക്കാനും വിവിധ സാഹചര്യങ്ങളിലും പ്രദേശങ്ങളിലും നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ സ്വഭാവത്തിൽ കൂടുതൽ ആത്മവിശ്വാസം നേടാനും കഴിയും. ഈ പാറ്റേണുകൾ സ്വീകരിക്കുന്നത് ലോകമെമ്പാടുമുള്ള ഡെവലപ്‌മെന്റ് ടീമുകളെ അസാധാരണമായ ഉപയോക്തൃ അനുഭവങ്ങൾ നൽകാൻ പ്രാപ്തരാക്കുന്നു.

നിങ്ങളുടെ ജാവാസ്ക്രിപ്റ്റ് ടെസ്റ്റിംഗ് രീതികളെ ഉയർത്താൻ ഈ നൂതന ടെക്നിക്കുകൾ ഇന്ന് തന്നെ നിങ്ങളുടെ വർക്ക്ഫ്ലോയിൽ ഉൾപ്പെടുത്താൻ തുടങ്ങുക.