ஜாவாஸ்கிரிப்ட் டெஸ்டிங்கில் தேர்ச்சி: வலிமையான பயன்பாடுகளுக்கான ஜெஸ்ட் கட்டமைப்பு மற்றும் தனிப்பயன் மேட்சர்கள்

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

ஏன் ஜெஸ்ட்? ஜாவாஸ்கிரிப்ட் டெஸ்டிங்கிற்கான ஒரு உலகளாவிய தரம்

கட்டமைப்பு மற்றும் தனிப்பயன் மேட்சர்களுக்குள் செல்வதற்கு முன், உலகெங்கிலும் உள்ள ஜாவாஸ்கிரிப்ட் டெவலப்பர்களுக்கு ஜெஸ்ட் ஏன் ஒரு விருப்பமான ஃபிரேம்வொர்க்காக மாறியுள்ளது என்பதைப் புரிந்துகொள்வோம்:

• பூஜ்ஜிய கட்டமைப்பு: ஜெஸ்ட் ஒரு குறிப்பிடத்தக்க எளிதான அமைப்பைக் கொண்டுள்ளது, இது குறைந்தபட்ச கட்டமைப்போடு டெஸ்ட்களை எழுத உங்களை அனுமதிக்கிறது. டெஸ்ட்-டிரைவன் டெவலப்மென்ட் (TDD) அல்லது பிஹேவியர்-டிரைவன் டெவலப்மென்ட் (BDD) நடைமுறைகளைப் பின்பற்றும் குழுக்களுக்கு இது மிகவும் பயனுள்ளதாக இருக்கும்.
• வேகமானது மற்றும் திறமையானது: ஜெஸ்ட்டின் இணை டெஸ்ட் இயக்கம் மற்றும் கேச்சிங் வழிமுறைகள் விரைவான டெஸ்ட் சுழற்சிகளுக்கு பங்களிக்கின்றன, டெவலப்மென்ட்டின் போது விரைவான பின்னூட்டத்தை வழங்குகின்றன.
• உள்ளமைக்கப்பட்ட மாக்கிங்: ஜெஸ்ட் சக்திவாய்ந்த மாக்கிங் திறன்களை வழங்குகிறது, இது குறியீட்டின் யூனிட்களை தனிமைப்படுத்தவும், திறமையான யூனிட் டெஸ்டிங்கிற்காக சார்புகளை உருவகப்படுத்தவும் உங்களை அனுமதிக்கிறது.
• ஸ்னாப்ஷாட் டெஸ்டிங்: ஜெஸ்ட்டின் ஸ்னாப்ஷாட் டெஸ்டிங் அம்சம் UI கூறுகள் மற்றும் தரவுக் கட்டமைப்புகளை சரிபார்க்கும் செயல்முறையை எளிதாக்குகிறது, எதிர்பாராத மாற்றங்களை எளிதில் கண்டறிய உதவுகிறது.
• சிறந்த ஆவணங்கள் மற்றும் சமூக ஆதரவு: ஜெஸ்ட் விரிவான ஆவணங்கள் மற்றும் ஒரு துடிப்பான சமூகத்தைக் கொண்டுள்ளது, இது தேவைப்படும்போது பதில்களைக் கண்டுபிடிப்பதையும் உதவி பெறுவதையும் எளிதாக்குகிறது. இது பல்வேறு சூழல்களில் உலகெங்கிலும் பணிபுரியும் டெவலப்பர்களுக்கு முக்கியமானது.
• பரவலான பயன்பாடு: ஸ்டார்ட்அப்கள் முதல் பெரிய நிறுவனங்கள் வரை உலகெங்கிலும் உள்ள நிறுவனங்கள், தங்கள் ஜாவாஸ்கிரிப்ட் பயன்பாடுகளை டெஸ்டிங் செய்ய ஜெஸ்ட்டை நம்பியுள்ளன. இந்த பரவலான பயன்பாடு தொடர்ச்சியான முன்னேற்றம் மற்றும் வளங்களின் செழுமையை உறுதி செய்கிறது.

ஜெஸ்ட்டை கட்டமைத்தல்: உங்கள் டெஸ்டிங் சூழலைத் தனிப்பயனாக்குதல்

ஜெஸ்ட் பூஜ்ஜிய-கட்டமைப்பு அனுபவத்தை வழங்கினாலும், உங்கள் திட்டத்தின் குறிப்பிட்ட தேவைகளுக்கு ஏற்ப அதைத் தனிப்பயனாக்குவது பெரும்பாலும் அவசியமாகிறது. ஜெஸ்ட்டை கட்டமைப்பதற்கான முதன்மை முறை உங்கள் திட்டத்தின் ரூட்டில் உள்ள `jest.config.js` கோப்பு (அல்லது நீங்கள் டைப்ஸ்கிரிப்ட் பயன்படுத்தினால் `jest.config.ts`) வழியாகும். சில முக்கிய கட்டமைப்பு விருப்பங்களை ஆராய்வோம்:

`transform`: உங்கள் குறியீட்டை மாற்றுதல்

டெஸ்ட்களை இயக்குவதற்கு முன்பு உங்கள் மூலக் குறியீட்டை ஜெஸ்ட் எவ்வாறு மாற்ற வேண்டும் என்பதை `transform` விருப்பம் குறிப்பிடுகிறது. நவீன ஜாவாஸ்கிரிப்ட் அம்சங்கள், JSX, டைப்ஸ்கிரிப்ட் அல்லது வேறு எந்த தரமற்ற சிண்டாக்ஸையும் கையாள்வதற்கு இது முக்கியமானது. பொதுவாக, நீங்கள் டிரான்ஸ்பைலேஷனுக்கு பேபலைப் பயன்படுத்துவீர்கள்.

எடுத்துக்காட்டு (`jest.config.js`):

module.exports = {
  transform: {
    '^.+\.js$': 'babel-jest',
    '^.+\.jsx$': 'babel-jest',
    '^.+\.ts?$': 'ts-jest',
  },
};

இந்த கட்டமைப்பு `.js` மற்றும் `.jsx` கோப்புகளை மாற்ற `babel-jest`-ஐயும், `.ts` கோப்புகளை மாற்ற `ts-jest`-ஐயும் பயன்படுத்த ஜெஸ்ட்டிடம் கூறுகிறது. தேவையான பேக்கேஜ்களை (`npm install --save-dev babel-jest @babel/core @babel/preset-env ts-jest typescript`) நிறுவியுள்ளீர்கள் என்பதை உறுதிப்படுத்தவும். உலகளாவிய குழுக்களுக்கு, அனைத்து பிராந்தியங்களிலும் பயன்படுத்தப்படும் பொருத்தமான ECMAScript பதிப்புகளை ஆதரிக்கும் வகையில் பேபல் கட்டமைக்கப்பட்டுள்ளதை உறுதிசெய்யவும்.

`testEnvironment`: செயல்பாட்டு சூழலை உருவகப்படுத்துதல்

உங்கள் டெஸ்ட்கள் எந்தச் சூழலில் இயங்கும் என்பதை `testEnvironment` விருப்பம் குறிப்பிடுகிறது. பொதுவான விருப்பங்களில் `node` (பேக்-எண்ட் குறியீட்டிற்கு) மற்றும் `jsdom` (DOM உடன் தொடர்பு கொள்ளும் ஃபிரன்ட்-எண்ட் குறியீட்டிற்கு) ஆகியவை அடங்கும்.

எடுத்துக்காட்டு (`jest.config.js`):

module.exports = {
  testEnvironment: 'jsdom',
};

`jsdom`-ஐப் பயன்படுத்துவது ஒரு உலாவிச் சூழலை உருவகப்படுத்துகிறது, இது ரியாக்ட் கூறுகள் அல்லது DOM-ஐச் சார்ந்திருக்கும் பிற குறியீடுகளை டெஸ்ட் செய்ய உங்களை அனுமதிக்கிறது. Node.js-அடிப்படையிலான பயன்பாடுகள் அல்லது பேக்-எண்ட் டெஸ்டிங்கிற்கு, `node` என்பது விருப்பமான தேர்வாகும். சர்வதேசமயமாக்கப்பட்ட பயன்பாடுகளுடன் பணிபுரியும்போது, உங்கள் இலக்கு பார்வையாளர்களுக்குப் பொருத்தமான லோகேல் அமைப்புகளை `testEnvironment` சரியாக உருவகப்படுத்துகிறது என்பதை உறுதிசெய்யவும்.

`moduleNameMapper`: மாட்யூல் இறக்குமதிகளைத் தீர்த்தல்

மாட்யூல் பெயர்களை வெவ்வேறு பாதைகளுக்கு மேப் செய்ய `moduleNameMapper` விருப்பம் உங்களை அனுமதிக்கிறது. மாட்யூல்களை மாக்கிங் செய்வதற்கும், அப்சல்யூட் இறக்குமதிகளைக் கையாள்வதற்கும், அல்லது பாத் மாற்றுப்பெயர்களைத் தீர்ப்பதற்கும் இது பயனுள்ளதாக இருக்கும்.

எடுத்துக்காட்டு (`jest.config.js`):

module.exports = {
  moduleNameMapper: {
    '^@components/(.*)$': '/src/components/$1',
  },
};

இந்த கட்டமைப்பு `@components/` உடன் தொடங்கும் இறக்குமதிகளை `src/components` டைரக்டரிக்கு மேப் செய்கிறது. இது இறக்குமதிகளை எளிதாக்குகிறது மற்றும் குறியீட்டின் வாசிப்புத்தன்மையை மேம்படுத்துகிறது. உலகளாவிய திட்டங்களுக்கு, அப்சல்யூட் இறக்குமதிகளைப் பயன்படுத்துவது வெவ்வேறு வரிசைப்படுத்தல் சூழல்கள் மற்றும் குழு கட்டமைப்புகளில் பராமரிப்பை மேம்படுத்தும்.

`testMatch`: டெஸ்ட் கோப்புகளைக் குறிப்பிடுதல்

டெஸ்ட் கோப்புகளைக் கண்டறியப் பயன்படுத்தப்படும் பேட்டர்ன்களை `testMatch` விருப்பம் வரையறுக்கிறது. இயல்பாக, ஜெஸ்ட் `.test.js`, `.spec.js`, `.test.jsx`, `.spec.jsx`, `.test.ts`, அல்லது `.spec.ts` இல் முடியும் கோப்புகளைத் தேடும். உங்கள் திட்டத்தின் பெயரிடல் மரபுகளுடன் பொருந்த இதை நீங்கள் தனிப்பயனாக்கலாம்.

எடுத்துக்காட்டு (`jest.config.js`):

module.exports = {
  testMatch: ['/src/**/*.test.js'],
};

இந்த கட்டமைப்பு `src` டைரக்டரி மற்றும் அதன் துணை டைரக்டரிகளுக்குள் `.test.js` இல் முடியும் டெஸ்ட் கோப்புகளைத் தேட ஜெஸ்ட்டிடம் கூறுகிறது. டெஸ்ட் கோப்புகளுக்கான நிலையான பெயரிடல் மரபுகள் பராமரிப்பிற்கு முக்கியமானவை, குறிப்பாக பெரிய, பரவலான குழுக்களில்.

`coverageDirectory`: கவரேஜ் வெளியீட்டைக் குறிப்பிடுதல்

குறியீட்டு கவரேஜ் அறிக்கைகளை ஜெஸ்ட் எங்கு வெளியிட வேண்டும் என்பதை `coverageDirectory` விருப்பம் குறிப்பிடுகிறது. உங்கள் டெஸ்ட்கள் உங்கள் பயன்பாட்டின் அனைத்து முக்கிய பகுதிகளையும் உள்ளடக்கியுள்ளன என்பதை உறுதிப்படுத்தவும், கூடுதல் டெஸ்டிங் தேவைப்படக்கூடிய பகுதிகளை அடையாளம் காணவும் குறியீட்டு கவரேஜ் பகுப்பாய்வு அவசியம்.

எடுத்துக்காட்டு (`jest.config.js`):

module.exports = {
  coverageDirectory: 'coverage',
};

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

`setupFilesAfterEnv`: செட்டப் குறியீட்டை இயக்குதல்

டெஸ்டிங் சூழல் அமைக்கப்பட்ட பிறகு இயக்கப்பட வேண்டிய கோப்புகளின் வரிசையை `setupFilesAfterEnv` விருப்பம் குறிப்பிடுகிறது. மாக்குகளை அமைப்பதற்கும், குளோபல் மாறிகளை கட்டமைப்பதற்கும், அல்லது தனிப்பயன் மேட்சர்களைச் சேர்ப்பதற்கும் இது பயனுள்ளதாக இருக்கும். தனிப்பயன் மேட்சர்களை வரையறுக்கும் போது பயன்படுத்த வேண்டிய நுழைவுப் புள்ளி இதுவாகும்.

எடுத்துக்காட்டு (`jest.config.js`):

module.exports = {
  setupFilesAfterEnv: ['/src/setupTests.js'],
};

சூழல் அமைக்கப்பட்ட பிறகு `src/setupTests.js` இல் உள்ள குறியீட்டை இயக்க இது ஜெஸ்ட்டிடம் கூறுகிறது. இங்குதான் உங்கள் தனிப்பயன் மேட்சர்களைப் பதிவு செய்வீர்கள், அதை அடுத்த பகுதியில் நாம் காண்போம்.

மற்ற பயனுள்ள கட்டமைப்பு விருப்பங்கள்

• `verbose`: கன்சோலில் விரிவான டெஸ்ட் முடிவுகளைக் காட்ட வேண்டுமா என்பதைக் குறிப்பிடுகிறது.
• `collectCoverageFrom`: எந்த கோப்புகள் குறியீட்டு கவரேஜ் அறிக்கைகளில் சேர்க்கப்பட வேண்டும் என்பதை வரையறுக்கிறது.
• `moduleDirectories`: மாட்யூல்களைத் தேட கூடுதல் டைரக்டரிகளைக் குறிப்பிடுகிறது.
• `clearMocks`: டெஸ்ட் இயக்கங்களுக்கு இடையில் மாக்குகளைத் தானாகவே அழிக்கிறது.
• `resetMocks`: ஒவ்வொரு டெஸ்ட் இயக்கத்திற்கும் முன் மாக்குகளை மீட்டமைக்கிறது.

தனிப்பயன் மேட்சர்களை உருவாக்குதல்: ஜெஸ்ட்டின் சரிபார்ப்புகளை விரிவுபடுத்துதல்

ஜெஸ்ட் `toBe`, `toEqual`, `toBeTruthy`, மற்றும் `toBeFalsy` போன்ற பல உள்ளமைக்கப்பட்ட மேட்சர்களை வழங்குகிறது. இருப்பினும், சிக்கலான தரவுக் கட்டமைப்புகள் அல்லது டொமைன்-சார்ந்த தர்க்கத்தைக் கையாளும் போது, சரிபார்ப்புகளை இன்னும் தெளிவாகவும் சுருக்கமாகவும் வெளிப்படுத்த தனிப்பயன் மேட்சர்களை உருவாக்க வேண்டிய நேரங்கள் உள்ளன. தனிப்பயன் மேட்சர்கள் குறியீட்டின் வாசிப்புத்தன்மையை மேம்படுத்துகின்றன மற்றும் நகலெடுப்பைக் குறைக்கின்றன, உங்கள் டெஸ்ட்களைப் புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் எளிதாக்குகின்றன.

ஒரு தனிப்பயன் மேட்சரை வரையறுத்தல்

தனிப்பயன் மேட்சர்கள் `received` மதிப்பை (டெஸ்ட் செய்யப்படும் மதிப்பு) பெறும் ஃபங்ஷன்களாக வரையறுக்கப்படுகின்றன மற்றும் இரண்டு பண்புகளைக் கொண்ட ஒரு ஆப்ஜெக்டைத் திருப்பித் தருகின்றன: `pass` (சரிபார்ப்பு வெற்றியடைந்ததா என்பதைக் குறிக்கும் ஒரு பூலியன்) மற்றும் `message` (சரிபார்ப்பு ஏன் வெற்றியடைந்தது அல்லது தோல்வியடைந்தது என்பதை விளக்கும் ஒரு செய்தியைத் தரும் ஃபங்ஷன்). ஒரு எண் ஒரு குறிப்பிட்ட வரம்பிற்குள் உள்ளதா என்பதைச் சரிபார்க்க ஒரு தனிப்பயன் மேட்சரை உருவாக்குவோம்.

எடுத்துக்காட்டு (`src/setupTests.js`):

expect.extend({
  toBeWithinRange(received, floor, ceiling) {
    const pass = received >= floor && received <= ceiling;
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to be within range ${floor} - ${ceiling}`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `expected ${received} to be within range ${floor} - ${ceiling}`,
        pass: false,
      };
    }
  },
});

இந்த எடுத்துக்காட்டில், `toBeWithinRange` என்ற ஒரு தனிப்பயன் மேட்சரை வரையறுக்கிறோம், அது மூன்று ஆர்கியுமெண்ட்களை எடுக்கும்: `received` மதிப்பு (டெஸ்ட் செய்யப்படும் எண்), `floor` (குறைந்தபட்ச மதிப்பு), மற்றும் `ceiling` (அதிகபட்ச மதிப்பு). இந்த மேட்சர் `received` மதிப்பு குறிப்பிட்ட வரம்பிற்குள் உள்ளதா என்பதைச் சரிபார்த்து, `pass` மற்றும் `message` பண்புகளுடன் ஒரு ஆப்ஜெக்டைத் திருப்பித் தருகிறது.

ஒரு தனிப்பயன் மேட்சரைப் பயன்படுத்துதல்

நீங்கள் ஒரு தனிப்பயன் மேட்சரை வரையறுத்தவுடன், வேறு எந்த உள்ளமைக்கப்பட்ட மேட்சரைப் போலவே அதை உங்கள் டெஸ்ட்களிலும் பயன்படுத்தலாம்.

எடுத்துக்காட்டு (`src/myModule.test.js`):

import './setupTests'; // தனிப்பயன் மேட்சர்கள் ஏற்றப்பட்டிருப்பதை உறுதிசெய்யவும்

describe('toBeWithinRange', () => {
  it('passes when the number is within the range', () => {
    expect(5).toBeWithinRange(1, 10);
  });

  it('fails when the number is outside the range', () => {
    expect(0).not.toBeWithinRange(1, 10);
  });
});

இந்த டெஸ்ட் தொகுப்பு `toBeWithinRange` தனிப்பயன் மேட்சரை எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டுகிறது. முதல் டெஸ்ட் கேஸ் 5 என்ற எண் 1 முதல் 10 வரையிலான வரம்பிற்குள் உள்ளது என்று சரிபார்க்கிறது, அதே நேரத்தில் இரண்டாவது டெஸ்ட் கேஸ் 0 என்ற எண் அதே வரம்பிற்குள் இல்லை என்று சரிபார்க்கிறது.

மேலும் சிக்கலான தனிப்பயன் மேட்சர்களை உருவாக்குதல்

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

எடுத்துக்காட்டு (`src/setupTests.js`):

expect.extend({
  toContainIgnoreCase(received, expected) {
    const pass = received.some(
      (item) => item.toLowerCase() === expected.toLowerCase()
    );
    if (pass) {
      return {
        message: () =>
          `expected ${received} not to contain ${expected} (case-insensitive)`,
        pass: true,
      };
    } else {
      return {
        message: () =>
          `expected ${received} to contain ${expected} (case-insensitive)`,
        pass: false,
      };
    }
  },
});

இந்த மேட்சர் `received` வரிசையின் மீது செயல்பட்டு, எந்த உறுப்புகளாவது லோயர்கேஸாக மாற்றப்படும்போது, `expected` மதிப்புடன் (லோயர்கேஸாக மாற்றப்பட்ட) பொருந்துகிறதா என்பதைச் சரிபார்க்கிறது. இது வரிசைகளில் கேஸ்-சென்சிடிவ் இல்லாத சரிபார்ப்புகளைச் செய்ய உங்களை அனுமதிக்கிறது.

சர்வதேசமயமாக்கல் (i18n) டெஸ்டிங்கிற்கான தனிப்பயன் மேட்சர்கள்

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

எடுத்துக்காட்டு (`src/setupTests.js` - இந்த எடுத்துக்காட்டு, கீகளை மொழிபெயர்க்கும் ஒரு ஃபங்ஷன் உங்களிடம் இருப்பதாகக் கருதுகிறது):

import { translate } from './i18n';

expect.extend({
  toHaveTranslation(received, key, locale) {
    const translatedString = translate(key, locale);
    const pass = received.includes(translatedString);

    if (pass) {
      return {
        message: () => `expected ${received} not to contain translation for key ${key} in locale ${locale}`,
        pass: true,
      };
    } else {
      return {
        message: () => `expected ${received} to contain translation for key ${key} in locale ${locale}`,
        pass: false,
      };
    }
  },
});

எடுத்துக்காட்டு (`src/i18n.js` - அடிப்படை மொழிபெயர்ப்பு எடுத்துக்காட்டு):

const translations = {
  en: {
    "welcome": "Welcome!"
  },
  fr: {
    "welcome": "Bienvenue!"
  }
}

export const translate = (key, locale) => {
  return translations[locale][key];
};

இப்போது உங்கள் டெஸ்ட்டில் (`src/myComponent.test.js`):

import './setupTests';

it('should display translated greeting in french', () => {
    const greeting = "Bienvenue!";
    expect(greeting).toHaveTranslation("welcome", "fr");
});

இந்த எடுத்துக்காட்டு, `Bienvenue!` என்பது பிரெஞ்சு மொழியில் "welcome" என்பதன் மொழிபெயர்க்கப்பட்ட மதிப்பா என்பதை டெஸ்ட் செய்கிறது. உங்கள் குறிப்பிட்ட சர்வதேசமயமாக்கல் லைப்ரரி அல்லது அணுகுமுறைக்கு ஏற்ப `translate` ஃபங்ஷனை மாற்றியமைப்பதை உறுதிசெய்யவும். சரியான i18n டெஸ்டிங் உங்கள் பயன்பாடுகள் பல்வேறு கலாச்சார பின்னணியைச் சேர்ந்த பயனர்களுடன் எதிரொலிப்பதை உறுதி செய்கிறது.

தனிப்பயன் மேட்சர்களின் நன்மைகள்

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

ஜெஸ்ட் கட்டமைப்பு மற்றும் தனிப்பயன் மேட்சர்களுக்கான சிறந்த நடைமுறைகள்

ஜெஸ்ட் கட்டமைப்பு மற்றும் தனிப்பயன் மேட்சர்களின் செயல்திறனை அதிகரிக்க, பின்வரும் சிறந்த நடைமுறைகளைக் கருத்தில் கொள்ளுங்கள்:

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

முடிவுரை: ஜெஸ்ட் மூலம் நம்பகமான ஜாவாஸ்கிரிப்ட் பயன்பாடுகளை உருவாக்குதல்

ஜெஸ்ட் ஒரு சக்திவாய்ந்த மற்றும் பல்துறை டெஸ்டிங் ஃபிரேம்வொர்க் ஆகும், இது உங்கள் ஜாவாஸ்கிரிப்ட் பயன்பாடுகளின் தரம் மற்றும் நம்பகத்தன்மையை கணிசமாக மேம்படுத்தும். ஜெஸ்ட் கட்டமைப்பில் தேர்ச்சி பெறுவதன் மூலமும், தனிப்பயன் மேட்சர்களை உருவாக்குவதன் மூலமும், உங்கள் திட்டத்தின் குறிப்பிட்ட தேவைகளைப் பூர்த்தி செய்ய உங்கள் டெஸ்டிங் சூழலைத் தனிப்பயனாக்கலாம், மேலும் வெளிப்படையான மற்றும் பராமரிக்கக்கூடிய டெஸ்ட்களை எழுதலாம், மேலும் உங்கள் குறியீடு பல்வேறு சூழல்கள் மற்றும் பயனர் தளங்களில் எதிர்பார்த்தபடி செயல்படுவதை உறுதி செய்யலாம். நீங்கள் ஒரு சிறிய வலை பயன்பாட்டை உருவாக்கினாலும் அல்லது ஒரு பெரிய அளவிலான நிறுவன அமைப்பை உருவாக்கினாலும், உலகளாவிய பார்வையாளர்களுக்காக வலிமையான மற்றும் நம்பகமான மென்பொருளை உருவாக்கத் தேவையான கருவிகளை ஜெஸ்ட் வழங்குகிறது. ஜெஸ்ட்டை ஏற்றுக்கொண்டு, உங்கள் ஜாவாஸ்கிரிப்ட் டெஸ்டிங் நடைமுறைகளை புதிய உயரங்களுக்கு உயர்த்துங்கள், உங்கள் பயன்பாடு உலகெங்கிலும் உள்ள பயனர்களைத் திருப்திப்படுத்தத் தேவையான தரங்களை பூர்த்தி செய்கிறது என்ற நம்பிக்கையுடன்.