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

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

ஜாவாஸ்கிரிப்ட் சோதனை உள்கட்டமைப்பு ஏன் முக்கியமானது?

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

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

ஜாவாஸ்கிரிப்ட் சோதனை உள்கட்டமைப்பின் முக்கிய கூறுகள்

ஒரு முழுமையான ஜாவாஸ்கிரிப்ட் சோதனை உள்கட்டமைப்பு பல முக்கிய கூறுகளை உள்ளடக்கியது, ஒவ்வொன்றும் மென்பொருள் தரத்தை உறுதி செய்வதில் முக்கிய பங்கு வகிக்கிறது.

1. சோதனை கட்டமைப்புகள்

சோதனைகளை எழுதவும் இயக்கவும் தேவையான கட்டமைப்பையும் கருவிகளையும் சோதனை கட்டமைப்புகள் வழங்குகின்றன. பிரபலமான ஜாவாஸ்கிரிப்ட் சோதனை கட்டமைப்புகளில் பின்வருவன அடங்கும்:

• Jest: ஃபேஸ்புக்கால் உருவாக்கப்பட்டது, Jest என்பது பூஜ்ஜிய உள்ளமைவு, ஸ்னாப்ஷாட் சோதனை மற்றும் சிறந்த போலி திறன்கள் போன்ற அம்சங்களை வழங்கும் ஒரு 'பேட்டரிகள்-உள்ளடக்கிய' சோதனை கட்டமைப்பாகும். இது ரியாக்ட் பயன்பாடுகளுக்கு ஒரு பிரபலமான தேர்வாகும் மற்றும் ஜாவாஸ்கிரிப்ட் சுற்றுச்சூழல் முழுவதும் இழுவை பெறுகிறது.
• Mocha: மோச்சா என்பது ஒரு நெகிழ்வான மற்றும் விரிவாக்கக்கூடிய சோதனை கட்டமைப்பாகும், இது உங்கள் உறுதிப்படுத்தல் நூலகம், போலி நூலகம் மற்றும் சோதனை ஓட்டியைத் தேர்வுசெய்ய உங்களை அனுமதிக்கிறது. இது தனிப்பயன் சோதனை பணிப்பாய்வுகளை உருவாக்குவதற்கான ஒரு திடமான அடித்தளத்தை வழங்குகிறது.
• Jasmine: ஜாஸ்மின் என்பது ஒரு நடத்தை-உந்துதல் மேம்பாட்டு (BDD) கட்டமைப்பாகும், இது சோதனைகளை எழுதுவதற்கான தூய்மையான மற்றும் படிக்கக்கூடிய தொடரியலை வழங்குகிறது. இது பெரும்பாலும் ஆங்குலர் திட்டங்களில் பயன்படுத்தப்படுகிறது.
• Cypress: சைப்ரஸ் என்பது ஒரு உலாவியில் இயங்கும் எதையும் சோதிக்க வடிவமைக்கப்பட்ட ஒரு இறுதி-க்கு-இறுதி சோதனை கட்டமைப்பாகும். இது ஒரு பயனர் நட்பு இடைமுகம் மற்றும் சக்திவாய்ந்த பிழைத்திருத்த கருவிகளை வழங்குகிறது.
• Playwright: மைக்ரோசாப்ட் உருவாக்கிய, பிளேரைட் என்பது ஒரு புதிய இறுதி-க்கு-இறுதி சோதனை கட்டமைப்பாகும், இது நம்பகமான குறுக்கு-உலாவி சோதனையை செயல்படுத்துகிறது.

எடுத்துக்காட்டு: Jest

ஒரு எளிய ஜாவாஸ்கிரிப்ட் செயல்பாட்டைக் கவனியுங்கள்:

function sum(a, b) {
  return a + b;
}

module.exports = sum;

இந்த செயல்பாட்டிற்கான ஒரு Jest சோதனை இங்கே:

const sum = require('./sum');

describe('sum', () => {
  it('should add two numbers correctly', () => {
    expect(sum(1, 2)).toBe(3);
  });
});

2. உறுதிப்படுத்தல் நூலகங்கள்

உங்கள் சோதனைகளில் எதிர்பார்க்கப்படும் நிபந்தனைகள் பூர்த்தி செய்யப்படுவதை உறுதிப்படுத்த முறைகளை உறுதிப்படுத்தல் நூலகங்கள் வழங்குகின்றன. பொதுவான உறுதிப்படுத்தல் நூலகங்கள் பின்வருமாறு:

• Chai: சாய் என்பது `expect`, `should`, மற்றும் `assert` ஆகிய மூன்று வெவ்வேறு பாணிகளை ஆதரிக்கும் ஒரு பல்துறை உறுதிப்படுத்தல் நூலகமாகும்.
• Assert (Node.js): Node.js இல் உள்ளமைக்கப்பட்ட `assert` தொகுதி ஒரு அடிப்படை உறுதிப்படுத்தல் முறைகளை வழங்குகிறது.
• Unexpected: Unexpected என்பது ஒரு நீட்டிக்கக்கூடிய உறுதிப்படுத்தல் நூலகமாகும், இது தனிப்பயன் உறுதிப்படுத்தல்களை வரையறுக்க உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு: Chai

const chai = require('chai');
const expect = chai.expect;

describe('Array', () => {
  it('should include a specific element', () => {
    const arr = [1, 2, 3];
    expect(arr).to.include(2);
  });
});

3. போலி நூலகங்கள்

போலி நூலகங்கள் உங்கள் சோதனைகளில் சார்புகளை கட்டுப்படுத்தப்பட்ட மாற்றுகளுடன் மாற்ற உங்களை அனுமதிக்கின்றன, இது குறியீட்டின் தனிப்பட்ட அலகுகளை தனிமைப்படுத்தி சோதிப்பதை எளிதாக்குகிறது. பிரபலமான போலி நூலகங்கள் பின்வருமாறு:

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

எடுத்துக்காட்டு: Sinon.JS

const sinon = require('sinon');
const myModule = require('./myModule');

describe('myFunction', () => {
  it('should call the dependency once', () => {
    const myDependency = {
      doSomething: () => {},
    };
    const spy = sinon.spy(myDependency, 'doSomething');
    myModule.myFunction(myDependency);
    expect(spy.calledOnce).to.be.true;
  });
});

4. சோதனை ஓட்டிகள்

சோதனை ஓட்டிகள் உங்கள் சோதனைகளை இயக்கி முடிவுகளில் கருத்துக்களை வழங்குகின்றன. பிரபலமான ஜாவாஸ்கிரிப்ட் சோதனை ஓட்டிகள் பின்வருமாறு:

• Jest: Jest அதன் சொந்த சோதனை ஓட்டியாக செயல்படுகிறது.
• Mocha: Mocha ஒரு தனி உறுதிப்படுத்தல் நூலகம் தேவைப்படுகிறது மற்றும் பல்வேறு அறிக்கையாளர்களுடன் பயன்படுத்தப்படலாம்.
• Karma: கர்மா என்பது உண்மையான உலாவிகளில் குறியீட்டைச் சோதிப்பதற்காக சிறப்பாக வடிவமைக்கப்பட்ட ஒரு சோதனை ஓட்டியாகும்.

5. தொடர்ச்சியான ஒருங்கிணைப்பு/தொடர்ச்சியான வரிசைப்படுத்தல் (CI/CD)

CI/CD என்பது ஒரு நவீன சோதனை உள்கட்டமைப்பின் ஒரு முக்கிய பகுதியாகும். குறியீடு மாற்றங்கள் செய்யப்படும் போதெல்லாம் சோதனைகளை இயக்கும் செயல்முறையை இது தானியங்குபடுத்துகிறது, உங்கள் குறியீட்டுத்தளம் நிலையானதாகவும் நம்பகமானதாகவும் இருப்பதை உறுதி செய்கிறது. பிரபலமான CI/CD தளங்கள் பின்வருமாறு:

• GitHub Actions: கிட்ஹப்பில் நேரடியாக ஒருங்கிணைக்கப்பட்டது, உங்கள் சோதனை மற்றும் வரிசைப்படுத்தல் பணிப்பாய்வுகளை தானியக்கமாக்குவதற்கு ஆக்ஷன்ஸ் ஒரு நெகிழ்வான மற்றும் சக்திவாய்ந்த தளத்தை வழங்குகிறது.
• Jenkins: ஜென்கின்ஸ் என்பது ஒரு திறந்த மூல CI/CD சேவையகமாகும், இது பரந்த அளவிலான செருகுநிரல்கள் மற்றும் ஒருங்கிணைப்புகளை வழங்குகிறது.
• CircleCI: CircleCI என்பது ஒரு கிளவுட் அடிப்படையிலான CI/CD தளமாகும், இது ஒரு நெறிப்படுத்தப்பட்ட மற்றும் பயன்படுத்த எளிதான இடைமுகத்தை வழங்குகிறது.
• Travis CI: டிராவிஸ் CI என்பது திறந்த மூல திட்டங்களுக்கு அடிக்கடி பயன்படுத்தப்படும் மற்றொரு கிளவுட் அடிப்படையிலான CI/CD தளமாகும்.
• GitLab CI/CD: GitLab அதன் தளத்திற்குள் நேரடியாக CI/CD அம்சங்களை உள்ளடக்கியது.

எடுத்துக்காட்டு: GitHub Actions

ஒவ்வொரு புஷ் மற்றும் புல் கோரிக்கைக்கும் Jest சோதனைகளை இயக்கும் ஒரு எளிய GitHub Actions பணிப்பாய்வு இங்கே:

name: Node CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Use Node.js 14.x
      uses: actions/setup-node@v2
      with:
        node-version: 14.x
    - name: npm install, build, and test
      run: |
        npm install
        npm run build --if-present
        npm test

6. குறியீடு பாதுகாப்பு கருவிகள்

குறியீடு பாதுகாப்பு கருவிகள் உங்கள் குறியீட்டுத் தளத்தின் எவ்வளவு சதவீதம் சோதனைகளால் மூடப்பட்டுள்ளது என்பதை அளவிடுகின்றன. இது போதுமான அளவு சோதிக்கப்படாத பகுதிகளை அடையாளம் காணவும், சோதனை முயற்சிகளுக்கு முன்னுரிமை அளிக்கவும் உதவுகிறது. பிரபலமான குறியீடு பாதுகாப்பு கருவிகள் பின்வருமாறு:

• Istanbul: இஸ்தான்புல் ஜாவாஸ்கிரிப்ட்டுக்கு பரவலாகப் பயன்படுத்தப்படும் குறியீடு பாதுகாப்பு கருவியாகும்.
• NYC: NYC என்பது இஸ்தான்புல்லுக்கான ஒரு கட்டளை வரி இடைமுகமாகும்.
• Jest-இன் உள்ளமைக்கப்பட்ட பாதுகாப்பு: Jest உள்ளமைக்கப்பட்ட குறியீடு பாதுகாப்பு செயல்பாட்டை உள்ளடக்கியது.

எடுத்துக்காட்டு: Jest குறியீடு பாதுகாப்பு

Jest-இல் குறியீடு பாதுகாப்பை இயக்க, உங்கள் சோதனை கட்டளையில் `--coverage` கொடியைச் சேர்க்கவும்:

npm test -- --coverage

இது `coverage` கோப்பகத்தில் ஒரு பாதுகாப்பு அறிக்கையை உருவாக்கும்.

7. நிலையான பகுப்பாய்வு கருவிகள்

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

• ESLint: ESLint என்பது ஒரு பிரபலமான லின்டர் ஆகும், இது குறியீட்டு தரங்களைச் செயல்படுத்தவும் சாத்தியமான பிழைகளைக் கண்டறியவும் உதவுகிறது.
• JSHint: JSHint என்பது ஜாவாஸ்கிரிப்டுக்கு பரவலாகப் பயன்படுத்தப்படும் மற்றொரு லின்டர் ஆகும்.
• TSLint: TSLint என்பது டைப்ஸ்கிரிப்ட் குறியீட்டிற்காக சிறப்பாக வடிவமைக்கப்பட்ட ஒரு லின்டர் ஆகும் (இப்போது ESLint-க்கு ஆதரவாக நிறுத்தப்பட்டது).
• SonarQube: SonarQube என்பது குறியீட்டு தரத்தை தொடர்ச்சியாக ஆய்வு செய்வதற்கான ஒரு தளமாகும்.

எடுத்துக்காட்டு: ESLint

ESLint-ஐ உள்ளமைக்க, உங்கள் திட்டத்தில் ஒரு `.eslintrc.js` கோப்பை உருவாக்கவும்:

module.exports = {
  "env": {
    "browser": true,
    "es2021": true,
    "node": true
  },
  "extends": [
    "eslint:recommended",
    "plugin:react/recommended"
  ],
  "parserOptions": {
    "ecmaFeatures": {
      "jsx": true
    },
    "ecmaVersion": 12,
    "sourceType": "module"
  },
  "plugins": [
    "react"
  ],
  "rules": {
    "semi": ["error", "always"],
    "quotes": ["error", "single"]
  }
};

ஜாவாஸ்கிரிப்ட் சோதனைகளின் வகைகள்

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

1. அலகு சோதனைகள்

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

2. ஒருங்கிணைப்பு சோதனைகள்

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

3. தொடக்கம் முதல் இறுதி வரை (E2E) சோதனைகள்

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

4. செயல்பாட்டு சோதனைகள்

செயல்பாட்டு சோதனைகள் உங்கள் பயன்பாட்டின் குறிப்பிட்ட அம்சங்கள் எதிர்பார்த்தபடி செயல்படுவதைச் சரிபார்க்கின்றன. அவை பயனரின் கண்ணோட்டத்தில் பயன்பாட்டின் செயல்பாட்டைச் சோதிப்பதில் கவனம் செலுத்துகின்றன. அவை E2E சோதனைகளைப் போலவே இருக்கின்றன, ஆனால் முழுமையான பணிப்பாய்வுகளை விட குறிப்பிட்ட செயல்பாடுகளில் கவனம் செலுத்தலாம்.

5. செயல்திறன் சோதனைகள்

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

ஒரு ஜாவாஸ்கிரிப்ட் சோதனை உள்கட்டமைப்பை செயல்படுத்துவதற்கான சிறந்த நடைமுறைகள்

ஒரு வலுவான ஜாவாஸ்கிரிப்ட் சோதனை உள்கட்டமைப்பை உருவாக்குவதற்கும் பராமரிப்பதற்கும் சில சிறந்த நடைமுறைகள் இங்கே:

• சோதனைகளை ஆரம்பத்திலும் அடிக்கடி எழுதுங்கள்: குறியீட்டை எழுதுவதற்கு முன் சோதனைகளை எழுத சோதனை-உந்துதல் மேம்பாடு (TDD) அல்லது நடத்தை-உந்துதல் மேம்பாடு (BDD) ஐத் தழுவுங்கள்.
• சோதனைகளை கவனம் செலுத்தி வைத்திருங்கள்: ஒவ்வொரு சோதனையும் உங்கள் குறியீட்டின் ஒரு அம்சத்தைச் சோதிப்பதில் கவனம் செலுத்த வேண்டும்.
• தெளிவான மற்றும் படிக்கக்கூடிய சோதனைகளை எழுதுங்கள்: உங்கள் சோதனைகள் மற்றும் உறுதிப்படுத்தல்களுக்கு விளக்கமான பெயர்களைப் பயன்படுத்தவும்.
• சோதனைகளில் சிக்கலான தர்க்கத்தைத் தவிர்க்கவும்: சோதனைகள் எளிமையாகவும் புரிந்துகொள்ள எளிதாகவும் இருக்க வேண்டும்.
• போலிகளைப் பொருத்தமாகப் பயன்படுத்தவும்: உங்கள் சோதனைகளைத் தனிமைப்படுத்த வெளிப்புற சார்புகளைப் போலி செய்யுங்கள்.
• சோதனைகளை தானாக இயக்கவும்: உங்கள் CI/CD பைப்லைனில் சோதனைகளை ஒருங்கிணைக்கவும்.
• குறியீடு பாதுகாப்பைக் கண்காணிக்கவும்: அதிக சோதனை தேவைப்படும் பகுதிகளை அடையாளம் காண குறியீடு பாதுகாப்பைக் கண்காணிக்கவும்.
• சோதனைகளைத் தவறாமல் மறுசீரமைக்கவும்: உங்கள் சோதனைகளை உங்கள் குறியீட்டுடன் புதுப்பித்த நிலையில் வைத்திருங்கள்.
• ஒரு நிலையான சோதனை பாணியைப் பயன்படுத்தவும்: உங்கள் திட்டம் முழுவதும் ஒரு நிலையான சோதனை பாணியை ஏற்றுக்கொள்ளுங்கள்.
• உங்கள் சோதனை உத்தியை ஆவணப்படுத்துங்கள்: உங்கள் சோதனை உத்தி மற்றும் வழிகாட்டுதல்களைத் தெளிவாக ஆவணப்படுத்துங்கள்.

சரியான கருவிகளைத் தேர்ந்தெடுப்பது

சோதனைக் கருவிகளின் தேர்வு உங்கள் திட்டத்தின் தேவைகள் மற்றும் குறிப்பிட்ட தேவைகளைப் பொறுத்தது. கருவிகளைத் தேர்ந்தெடுக்கும்போது பின்வரும் காரணிகளைக் கவனியுங்கள்:

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

எடுத்துக்காட்டு செயலாக்கம்: Jest மற்றும் GitHub Actions உடன் ஒரு சோதனை உள்கட்டமைப்பை உருவாக்குதல்

சோதனைக்கு Jest மற்றும் CI/CD-க்கு GitHub Actions ஐப் பயன்படுத்தி ஒரு ஜாவாஸ்கிரிப்ட் சோதனை உள்கட்டமைப்பின் முழுமையான செயலாக்கத்தை விளக்குவோம்.

படி 1: திட்ட அமைப்பு

ஒரு புதிய ஜாவாஸ்கிரிப்ட் திட்டத்தை உருவாக்கவும்:

mkdir my-project
cd my-project
npm init -y

படி 2: Jest-ஐ நிறுவவும்

npm install --save-dev jest

படி 3: ஒரு சோதனை கோப்பை உருவாக்கவும்

`sum.js` என்ற பெயரில் ஒரு கோப்பை உருவாக்கவும்:

function sum(a, b) {
  return a + b;
}

module.exports = sum;

`sum.test.js` என்ற பெயரில் ஒரு சோதனை கோப்பை உருவாக்கவும்:

const sum = require('./sum');

describe('sum', () => {
  it('should add two numbers correctly', () => {
    expect(sum(1, 2)).toBe(3);
  });
});

படி 4: Jest-ஐ உள்ளமைக்கவும்

சோதனை ஸ்கிரிப்டை உள்ளமைக்க உங்கள் `package.json` கோப்பில் பின்வரும் வரியைச் சேர்க்கவும்:

"scripts": {
  "test": "jest"
}

படி 5: சோதனைகளை உள்ளூரில் இயக்கவும்

npm test

படி 6: GitHub Actions-ஐ உள்ளமைக்கவும்

`.github/workflows/node.js.yml` என்ற பெயரில் ஒரு கோப்பை உருவாக்கவும்:

name: Node CI

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Use Node.js 14.x
      uses: actions/setup-node@v2
      with:
        node-version: 14.x
    - name: npm install, build, and test
      run: |
        npm install
        npm run build --if-present
        npm test

படி 7: உங்கள் குறியீட்டை கமிட் செய்து புஷ் செய்யவும்

உங்கள் மாற்றங்களை கமிட் செய்து GitHub-க்கு புஷ் செய்யவும். GitHub Actions ஒவ்வொரு புஷ் மற்றும் புல் கோரிக்கையிலும் உங்கள் சோதனைகளை தானாகவே இயக்கும்.

உலகளாவிய பரிசீலனைகள்

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

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

முடிவுரை

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