உண்மையாக இயங்கும் சோதனைகள்

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

சில சோதனைகளை எழுதுங்கள்இலவசமாக முயற்சிக்கலாம். நிறுவுவதற்கு எதுவும் இல்லை.

இது எவ்வாறு இயங்குகிறது

மூன்று படிகள், அதில் எதுவும் “கட்டமைத்தல்” இல்லை.

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

இது என்ன செய்ய முடியும்

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

இது எவ்வாறு அமைக்கப்பட்டுள்ளது

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

சூழல்: Node 22 மற்றும் Python 3 கொண்ட ஒரு Linux கன்டெய்னர். சோதனைகள் அங்கு இயங்கும், மேலும் வெளியீடு கோப்பிற்கு கீழே உள்ள டெர்மினல் பலகத்தில் தோன்றும்.
கருவிகள்: கோப்புகளைப் படிக்க, எழுத மற்றும் திருத்த, glob, grep, மற்றும் தொகுப்பை இயக்குவதற்குக் கட்டளைச் சரம் (shell).
மாடல்: ஏதேனும் சாட் மாடல். இது ஒரு சுழற்சியை இயக்குகிறது — எழுது, இயக்கு, படி, தீர்மானி — எனவே வேகமாக எழுதுவதை விட வெளியீட்டைக் கவனமாகப் படிக்கும் மாடலுக்கு இது முன்னுரிமை அளிக்கிறது.
தொடக்கக் கோப்புகள்: இரண்டு உண்மையான பிழைகளைக் கொண்ட ஒரு சிறிய செக்அவுட் மாடியூல், இரண்டும் எல்லை தொடர்பானவை, எனவே முதல் இயக்கம் வெற்றி பெறுவதற்குப் பதிலாக ஏஜென்ட் உருவாக்கப்பட்ட நோக்கத்தை அடைகிறது.
எது சேமிக்கப்படும்: சோதனைகள் tests கோப்பகத்தில் எழுதப்பட்டு அங்கேயே இருக்கும். கோப்பில் உள்ள Run பொத்தானைப் பயன்படுத்தி அவற்றில் எதையும் நீங்களே மீண்டும் இயக்கலாம்.

மக்கள் இதனிடம் கேட்கும் விஷயங்கள்

“cart.js-க்கான சோதனைகளை எழுதி, அவற்றை இயக்கி, நீங்கள் என்ன கண்டறிந்தீர்கள் என்று எனக்குச் சொல்லுங்கள்.”
“இலவச டெலிவரி விதியை துல்லியமான எல்லையிலும், அதன் இருபுறமும் சோதிக்கவும்.”
“இந்தக் கோப்பில் எது சோதிக்கப்படவில்லை?”
“இந்தச் சோதனைகள் தேர்ச்சியடைகின்றன, ஆனால் எனக்கு நம்பிக்கையில்லை — அவை எதைச் சோதிக்கவில்லை?”

இது எதைச் செய்யாது

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

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

எந்த மாடல் இதைச் சிறப்பாகச் செய்கிறது

விரைவில் வருகிறது

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

நிறைவு விகிதம்

நீங்கள் தலையிட வேண்டிய அவசியமின்றி வேலையை முடித்த இயக்கங்கள்.

இடைநிலைச் செலவு

ஒரு சாதாரண இயக்கத்திற்கு ஆகும் செலவு, கிரெடிட்களில்.

இடைநிலை நேரம்

முதல் செய்தியிலிருந்து பதில் வரும் வரையிலான கணக்கிடப்பட்ட நேரம்.