ஜாவாஸ்கிரிப்ட் சோதனை ஆட்டோமேஷன்: தொடர்ச்சியான ஒருங்கிணைப்பு அமைப்புக்கான ஒரு விரிவான வழிகாட்டி

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

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

'ஏன்': CI-இன் அடிப்படைக் கொள்கைகளைப் புரிந்துகொள்ளுதல்

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

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

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

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

CI-ஐ ஏற்றுக்கொள்வதன் முக்கிய நன்மைகள்

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

'என்ன': ஜாவாஸ்கிரிப்ட் சோதனையின் ஒரு பரந்த பார்வை

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

ஒரு பிரமிடைக் கற்பனை செய்து பாருங்கள்:

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

யூனிட் சோதனைகள்: அடித்தளம்

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

• நோக்கம்: தனிப்பட்ட லாஜிக் யூனிட்களை சரிபார்க்க.
• வேகம்: மிகவும் வேகம் (ஒரு சோதனைக்கு மில்லி விநாடிகள்).
• முக்கிய கருவிகள்:
  • Jest: ஒரு பிரபலமான, ஆல்-இன்-ஒன் சோதனை கட்டமைப்பு, உள்ளமைக்கப்பட்ட அசெர்ஷன் லைப்ரரிகள், மாக்கிங் திறன்கள் மற்றும் கோட் கவரேஜ் கருவிகளைக் கொண்டுள்ளது. மெட்டாவால் பராமரிக்கப்படுகிறது.
  • Vitest: Vite பில்ட் கருவியுடன் தடையின்றி வேலை செய்ய வடிவமைக்கப்பட்ட ஒரு நவீன, அதிவேக சோதனை கட்டமைப்பு, இது Jest-இணக்கமான API-ஐ வழங்குகிறது.
  • Mocha: சோதனைகளுக்கான அடிப்படை கட்டமைப்பை வழங்கும் ஒரு மிகவும் நெகிழ்வான மற்றும் முதிர்ந்த சோதனை கட்டமைப்பு. இது பெரும்பாலும் Chai போன்ற ஒரு அசெர்ஷன் லைப்ரரியுடன் இணைக்கப்படுகிறது.

இன்டக்ரேஷன் சோதனைகள்: இணைப்பிழையம்

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

• நோக்கம்: தொகுதிகள் அல்லது கூறுகளுக்கு இடையிலான ஊடாடல்களை சரிபார்க்க.
• வேகம்: யூனிட் சோதனைகளை விட மெதுவானது ஆனால் E2E சோதனைகளை விட வேகமானது.
• முக்கிய கருவிகள்:
  • React Testing Library: இது ஒரு டெஸ்ட் ரன்னர் அல்ல, ஆனால் செயலாக்க விவரங்களை விட பயன்பாட்டு நடத்தையை சோதிக்க ஊக்குவிக்கும் கருவிகளின் தொகுப்பு. இது Jest அல்லது Vitest போன்ற ரன்னர்களுடன் வேலை செய்கிறது.
  • Supertest: Node.js HTTP சேவையகங்களை சோதிப்பதற்கான ஒரு பிரபலமான லைப்ரரி, இது API இன்டக்ரேஷன் சோதனைகளுக்கு சிறந்தது.

எண்ட்-டு-எண்ட் (E2E) சோதனைகள்: பயனரின் பார்வை

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

• நோக்கம்: முழுமையான பயனர் பாய்வுகளை ஆரம்பம் முதல் இறுதி வரை சரிபார்க்க.
• வேகம்: மெதுவான மற்றும் மிகவும் உடையக்கூடிய வகை சோதனை.
• முக்கிய கருவிகள்:
  • Cypress: ஒரு நவீன, ஆல்-இன்-ஒன் E2E சோதனை கட்டமைப்பு, அதன் சிறந்த டெவலப்பர் அனுபவம், ஊடாடும் டெஸ்ட் ரன்னர் மற்றும் நம்பகத்தன்மைக்காக அறியப்படுகிறது.
  • Playwright: மைக்ரோசாப்ட்டிலிருந்து ஒரு சக்திவாய்ந்த கட்டமைப்பு, இது ஒற்றை API உடன் கிராஸ்-பிரவுசர் ஆட்டோமேஷனை (Chromium, Firefox, WebKit) செயல்படுத்துகிறது. இது அதன் வேகம் மற்றும் மேம்பட்ட அம்சங்களுக்காக அறியப்படுகிறது.
  • Selenium WebDriver: பிரவுசர் ஆட்டோமேஷனுக்கான நீண்டகால தரநிலை, இது பரந்த அளவிலான மொழிகளையும் பிரவுசர்களையும் ஆதரிக்கிறது. இது அதிகபட்ச நெகிழ்வுத்தன்மையை வழங்குகிறது ஆனால் அமைப்பதற்கு மிகவும் சிக்கலானதாக இருக்கலாம்.

நிலையான பகுப்பாய்வு: முதல் தற்காப்பு வரிசை

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

• ESLint: சாத்தியமான பிழைகள் முதல் ஸ்டைல் மீறல்கள் வரை உங்கள் ஜாவாஸ்கிரிப்ட் கோடில் உள்ள சிக்கல்களைக் கண்டறிந்து சரிசெய்ய மிகவும் கட்டமைக்கக்கூடிய ஒரு லின்டர்.
• Prettier: உங்கள் முழு குழுவிலும் ஒரு நிலையான கோட் ஸ்டைலை உறுதி செய்யும் ஒரு கருத்துடைய கோட் ஃபார்மேட்டர், ஃபார்மேட்டிங் குறித்த விவாதங்களை நீக்குகிறது.
• TypeScript: ஜாவாஸ்கிரிப்டில் நிலையான வகைகளைச் சேர்ப்பதன் மூலம், TypeScript கோட் இயக்கப்படுவதற்கு நீண்ட காலத்திற்கு முன்பே, கம்பைல்-டைமில் ஒரு முழு வகை பிழைகளைப் பிடிக்க முடியும்.

'எப்படி': உங்கள் CI பைப்லைனை உருவாக்குதல் - ஒரு நடைமுறை வழிகாட்டி

இப்போது, நடைமுறைக்கு வருவோம். உலகளவில் மிகவும் பிரபலமான மற்றும் அணுகக்கூடிய CI/CD தளங்களில் ஒன்றான GitHub Actions-ஐப் பயன்படுத்தி ஒரு CI பைப்லைனை உருவாக்குவதில் நாம் கவனம் செலுத்துவோம். இருப்பினும், கருத்துக்கள் GitLab CI/CD அல்லது Jenkins போன்ற பிற அமைப்புகளுக்கு நேரடியாக மாற்றத்தக்கவை.

முன் தேவைகள்

1. ஒரு ஜாவாஸ்கிரிப்ட் திட்டம் (Node.js, React, Vue, போன்றவை).
2. ஒரு சோதனை கட்டமைப்பு நிறுவப்பட்டுள்ளது (யூனிட் சோதனைகளுக்கு Jest மற்றும் E2E சோதனைகளுக்கு Cypress-ஐப் பயன்படுத்துவோம்).
3. உங்கள் கோட் GitHub-இல் ஹோஸ்ட் செய்யப்பட்டுள்ளது.
4. உங்கள் `package.json` கோப்பில் வரையறுக்கப்பட்ட ஸ்கிரிப்ட்கள்.

ஒரு பொதுவான `package.json` இது போன்ற ஸ்கிரிப்ட்களைக் கொண்டிருக்கலாம்:

எடுத்துக்காட்டு `package.json` ஸ்கிரிப்ட்கள்:

"scripts": {

"start": "react-scripts start",

"build": "react-scripts build",

"lint": "eslint .",

"test": "jest",

"test:ci": "jest --ci --coverage",

"cypress:open": "cypress open",

"cypress:run": "cypress run"

}

படி 1: உங்கள் முதல் GitHub Actions வொர்க்ஃப்ளோவை அமைத்தல்

GitHub Actions உங்கள் ரெபாசிட்டரியின் `.github/workflows/` கோப்பகத்தில் உள்ள YAML கோப்புகளில் வரையறுக்கப்படுகின்றன. `ci.yml` என்ற கோப்பை உருவாக்குவோம்.

கோப்பு: `.github/workflows/ci.yml`

இந்த வொர்க்ஃப்ளோ `main` பிராஞ்சிற்கான ஒவ்வொரு புஷ் மற்றும் `main`-ஐ இலக்காகக் கொண்ட ஒவ்வொரு புல் கோரிக்கை மீதும் எங்கள் லின்டர்கள் மற்றும் யூனிட் சோதனைகளை இயக்கும்.

# இது உங்கள் வொர்க்ஃப்ளோவிற்கான பெயர்

name: JavaScript CI

# இந்த பிரிவு வொர்க்ஃப்ளோ எப்போது இயங்கும் என்பதை வரையறுக்கிறது

on:

push:

branches: [ "main" ]

pull_request:

branches: [ "main" ]

# இந்த பிரிவு செயல்படுத்தப்பட வேண்டிய ஜாப்களை வரையறுக்கிறது

jobs:

# 'test' என்ற பெயரில் ஒரு ஜாப்பை வரையறுக்கிறோம்

test:

# ஜாப்பை இயக்க வேண்டிய மெய்நிகர் இயந்திரத்தின் வகை

runs-on: ubuntu-latest

# ஸ்டெப்ஸ் என்பது செயல்படுத்தப்படும் பணிகளின் வரிசையைக் குறிக்கிறது

steps:

# படி 1: உங்கள் ரெபாசிட்டரியின் கோடை சரிபார்க்கவும்

- name: Checkout code

uses: actions/checkout@v4

# படி 2: Node.js இன் சரியான பதிப்பை அமைக்கவும்

- name: Use Node.js 20.x

uses: actions/setup-node@v4

with:

node-version: '20.x'

cache: 'npm' # இது npm சார்புகளை கேச் செய்ய உதவுகிறது

# படி 3: திட்ட சார்புகளை நிறுவவும்

- name: Install dependencies

run: npm ci

# படி 4: கோட் ஸ்டைலை சரிபார்க்க லின்டரை இயக்கவும்

- name: Run linter

run: npm run lint

# படி 5: யூனிட் மற்றும் இன்டக்ரேஷன் சோதனைகளை இயக்கவும்

- name: Run unit tests

run: npm run test:ci

இந்த கோப்பை கமிட் செய்து GitHub-க்கு புஷ் செய்தவுடன், உங்கள் CI பைப்லைன் நேரலையில் இருக்கும்! அது இயங்குவதைக் காண உங்கள் GitHub ரெபாசிட்டரியில் உள்ள 'Actions' தாவலுக்குச் செல்லவும்.

படி 2: சைப்ரஸ் உடன் எண்ட்-டு-எண்ட் சோதனைகளை ஒருங்கிணைத்தல்

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

பல அமைவுப் படிகளை எளிதாக்கும் அதிகாரப்பூர்வ `cypress-io/github-action`-ஐப் பயன்படுத்துவோம்.

புதுப்பிக்கப்பட்ட கோப்பு: `.github/workflows/ci.yml`

name: JavaScript CI

on:

push:

branches: [ "main" ]

pull_request:

branches: [ "main" ]

jobs:

# யூனிட் சோதனை ஜாப் அப்படியே இருக்கும்

unit-tests:

runs-on: ubuntu-latest

steps:

- uses: actions/checkout@v4

- uses: actions/setup-node@v4

with:

node-version: '20.x'

cache: 'npm'

- run: npm ci

- run: npm run lint

- run: npm run test:ci

# E2E சோதனைகளுக்கு ஒரு புதிய, இணையான ஜாப்பைச் சேர்க்கிறோம்

e2e-tests:

runs-on: ubuntu-latest

# இந்த ஜாப் unit-tests ஜாப் வெற்றி பெற்றால் மட்டுமே இயங்க வேண்டும்

needs: unit-tests

steps:

- uses: actions/checkout@v4

- uses: actions/setup-node@v4

with:

node-version: '20.x'

cache: 'npm'

- name: Install dependencies

run: npm ci

# அதிகாரப்பூர்வ Cypress ஆக்ஷனைப் பயன்படுத்தவும்

- name: Cypress run

uses: cypress-io/github-action@v6

with:

# E2E சோதனைகளை இயக்கும் முன் பயன்பாட்டை பில்ட் செய்ய வேண்டும்

build: npm run build

# உள்ளூர் சேவையகத்தைத் தொடங்குவதற்கான கட்டளை

start: npm start

# சோதனைகளுக்குப் பயன்படுத்த வேண்டிய பிரவுசர்

browser: chrome

# இந்த URL-இல் சேவையகம் தயாராகும் வரை காத்திருக்கவும்

wait-on: 'http://localhost:3000'

இந்த அமைப்பு இரண்டு ஜாப்களை உருவாக்குகிறது. `e2e-tests` ஜாப்பிற்கு `unit-tests` ஜாப் `தேவை`, அதாவது முதல் ஜாப் வெற்றிகரமாக முடிந்த பின்னரே அது தொடங்கும். இது ஒரு வரிசைமுறை பைப்லைனை உருவாக்குகிறது, மெதுவான, அதிக செலவு மிக்க E2E சோதனைகளை இயக்கும் முன் அடிப்படை கோட் தரத்தை உறுதி செய்கிறது.

மாற்று CI/CD தளங்கள்: ஒரு உலகளாவிய பார்வை

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

GitLab CI/CD

GitLab ஒரு ஆழமாக ஒருங்கிணைக்கப்பட்ட மற்றும் சக்திவாய்ந்த CI/CD தீர்வைக் கொண்டுள்ளது. உங்கள் ரெபாசிட்டரியின் ரூட்டில் உள்ள `.gitlab-ci.yml` கோப்பு வழியாக கட்டமைப்பு செய்யப்படுகிறது.

ஒரு எளிமைப்படுத்தப்பட்ட `.gitlab-ci.yml` எடுத்துக்காட்டு:

image: node:20

cache:

paths:

- node_modules/

stages:

- setup

- test

install_dependencies:

stage: setup

script:

- npm ci

run_unit_tests:

stage: test

script:

- npm run test:ci

run_linter:

stage: test

script:

- npm run lint

Jenkins

Jenkins என்பது மிகவும் விரிவாக்கக்கூடிய, சுயமாக ஹோஸ்ட் செய்யப்படும் ஆட்டோமேஷன் சர்வர். அதிகபட்ச கட்டுப்பாடு மற்றும் தனிப்பயனாக்கம் தேவைப்படும் பெருநிறுவன சூழல்களில் இது ஒரு பிரபலமான தேர்வாகும். Jenkins பைப்லைன்கள் பொதுவாக ஒரு `Jenkinsfile`-இல் வரையறுக்கப்படுகின்றன.

ஒரு எளிமைப்படுத்தப்பட்ட அறிவிப்பு `Jenkinsfile` எடுத்துக்காட்டு:

pipeline {

agent any

stages {

stage('Build') {

steps {

sh 'npm ci'

}

}

stage('Test') {

steps {

sh 'npm run lint'

sh 'npm run test:ci'

}

}

}

}

மேம்பட்ட CI உத்திகள் மற்றும் சிறந்த நடைமுறைகள்

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

இணையாக்கம் மற்றும் கேச்சிங்

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

கேச்சிங்: ஒவ்வொரு CI ரன்னிலும் `node_modules`-ஐ மீண்டும் நிறுவுவது நேரத்தை வீணடிக்கும். அனைத்து முக்கிய CI தளங்களும் இந்த சார்புகளை கேச் செய்வதற்கான ஒரு பொறிமுறையை வழங்குகின்றன. எங்கள் GitHub Actions எடுத்துக்காட்டில் (`cache: 'npm'`) காட்டப்பட்டுள்ளபடி, முதல் ரன் மெதுவாக இருக்கும், ஆனால் அடுத்தடுத்த ரன்கள் கேச்சை மீட்டெடுக்க முடியுமென்பதால் கணிசமாக வேகமாக இருக்கும்.

கோட் கவரேஜ் அறிக்கை

கோட் கவரேஜ் உங்கள் கோடின் எத்தனை சதவீதம் உங்கள் சோதனைகளால் இயக்கப்படுகிறது என்பதை அளவிடுகிறது. 100% கவரேஜ் எப்போதும் ஒரு நடைமுறை அல்லது பயனுள்ள குறிக்கோள் இல்லை என்றாலும், இந்த அளவீட்டைக் கண்காணிப்பது உங்கள் பயன்பாட்டின் சோதிக்கப்படாத பகுதிகளை அடையாளம் காண உதவும். Jest போன்ற கருவிகள் கவரேஜ் அறிக்கைகளை உருவாக்க முடியும். காலப்போக்கில் கவரேஜைக் கண்காணிக்கவும், கவரேஜ் ஒரு குறிப்பிட்ட வரம்பிற்குக் கீழே குறைந்தால் ஒரு பில்டைத் தோல்வியடையச் செய்யவும் உங்கள் CI பைப்லைனில் Codecov அல்லது Coveralls போன்ற சேவைகளை ஒருங்கிணைக்கலாம்.

Codecov-க்கு கவரேஜை பதிவேற்றுவதற்கான எடுத்துக்காட்டு படி:

- name: Upload coverage to Codecov

uses: codecov/codecov-action@v4

with:

token: ${{ secrets.CODECOV_TOKEN }}

ரகசியங்கள் மற்றும் சூழல் மாறிகளைக் கையாளுதல்

உங்கள் பயன்பாட்டிற்கு API விசைகள், தரவுத்தள சான்றுகள் அல்லது பிற முக்கிய தகவல்கள் தேவைப்படலாம், குறிப்பாக E2E சோதனைகளுக்கு. ஒருபோதும் இவற்றை நேரடியாக உங்கள் கோடில் சேர்க்க வேண்டாம். ஒவ்வொரு CI தளமும் ரகசியங்களைச் சேமிக்க ஒரு பாதுகாப்பான வழியை வழங்குகிறது.

• GitHub Actions-இல், அவற்றை `Settings > Secrets and variables > Actions`-இல் சேமிக்கலாம். பின்னர் அவை உங்கள் வொர்க்ஃப்ளோவில் `secrets` சூழல் வழியாக, `${{ secrets.MY_API_KEY }}` போல அணுகக்கூடியவை.
• GitLab CI/CD-இல், இவை `Settings > CI/CD > Variables` கீழ் நிர்வகிக்கப்படுகின்றன.
• Jenkins-இல், அதன் உள்ளமைக்கப்பட்ட Credentials Manager மூலம் சான்றுகளை நிர்வகிக்கலாம்.

நிபந்தனைக்குட்பட்ட வொர்க்ஃப்ளோக்கள் மற்றும் மேம்படுத்தல்கள்

ஒவ்வொரு கமிட்டிலும் ஒவ்வொரு ஜாப்பையும் இயக்க வேண்டிய அவசியமில்லை. நேரத்தையும் வளங்களையும் சேமிக்க உங்கள் பைப்லைனை மேம்படுத்தலாம்:

• `main` பிராஞ்சிற்கு புல் கோரிக்கைகள் அல்லது மெர்ஜ்களில் மட்டும் விலை உயர்ந்த E2E சோதனைகளை இயக்கவும்.
• `paths-ignore`-ஐப் பயன்படுத்தி ஆவணப்படுத்தல் மட்டுமேயான மாற்றங்களுக்கு CI ரன்களைத் தவிர்க்கவும்.
• உங்கள் கோடை பல Node.js பதிப்புகள் அல்லது இயக்க முறைமைகளுக்கு எதிராக ஒரே நேரத்தில் சோதிக்க மேட்ரிக்ஸ் உத்திகளைப் பயன்படுத்தவும்.

CI-க்கு அப்பால்: தொடர்ச்சியான வரிசைப்படுத்தலுக்கான (CD) பாதை

தொடர்ச்சியான ஒருங்கிணைப்பு சமன்பாட்டின் முதல் பாதியாகும். സ്വാഭാവിക அடுத்த படி தொடர்ச்சியான டெலிவரி அல்லது தொடர்ச்சியான வரிசைப்படுத்தல் (CD) ஆகும்.

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

`main` பிராஞ்சிற்கு ஒரு வெற்றிகரமான மெர்ஜில் மட்டுமே தூண்டப்படும் ஒரு `deploy` ஜாப்பை உங்கள் CI வொர்க்ஃப்ளோவில் சேர்க்கலாம். இந்த ஜாப் உங்கள் பயன்பாட்டை Vercel, Netlify, AWS, Google Cloud அல்லது உங்கள் சொந்த சேவையகங்கள் போன்ற தளங்களில் வரிசைப்படுத்த ஸ்கிரிப்ட்களை இயக்கும்.

GitHub Actions-இல் ஒரு கருத்தியல் deploy ஜாப்:

deploy:

needs: [unit-tests, e2e-tests]

runs-on: ubuntu-latest

# இந்த ஜாப்பை முக்கிய பிராஞ்சிற்கான புஷ்களில் மட்டுமே இயக்கவும்

if: github.ref == 'refs/heads/main' && github.event_name == 'push'

steps:

# ... checkout, setup, build படிகள் ...

- name: Deploy to Production

run: ./deploy-script.sh # உங்கள் வரிசைப்படுத்தல் கட்டளை

env:

DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}

முடிவுரை: இது ஒரு கருவி மட்டுமல்ல, ஒரு கலாச்சார மாற்றம்

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

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

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