Back to Question Center
0

ஜஸ்ட் பயன்படுத்தி கூறுகள் பதில் சோதிக்க எப்படி            JestRelated தலைப்புகள் பயன்படுத்தி கூறுகள் சோதிக்க எப்படி: Node.jsnpmRem Semalt

1 answers:
ஜஸ்ட் பயன்படுத்தி கூறுகள் சோதனை சோதிக்க எப்படி

உயர் தர, ஆழ்ந்த அறிமுகப்படுத்தியதற்கு, கனேடியின் முழு ஸ்டாக் டெவலப்பர் வெஸ் போஸ் கடந்த காலத்தை நீங்கள் கடக்க முடியாது. இங்கே தனது படிப்பைத் தொடரவும், SITEPOINT ஐப் பயன்படுத்தவும் 25% ஆஃப் ஆஃப் மற்றும் தள தளத்தை ஆதரிக்க உதவும்.

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

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

How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt

மாதிரி விண்ணப்பம்

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

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

பயன்பாட்டின் நுழைவு புள்ளி பயன்பாடு / குறியீட்டு. js , இது தான் டோடோஸ் கூறுகளை HTML க்குள் வழங்குகிறது:

     <டொடோஸ் /> ,ஆவணம். getElementById ( 'பயன்பாடு'));    

டோடோஸ் பகுதி பயன்பாட்டின் முக்கிய மையமாகும். இது அனைத்து மாநிலத்திலும் (இந்த பயன்பாட்டிற்கான கடின குறியீட்டு தரவு, உண்மையில் ஒரு ஏபிஐ அல்லது இது போன்றது), மற்றும் இரண்டு குழந்தை கூறுகளை வழங்குவதற்கான குறியீட்டை கொண்டுள்ளது: டோடோ , இது ஒரு முறை AddTodo , ஒரு முறை வழங்கப்பட்டது மற்றும் ஒரு புதிய டூடோ சேர்க்க ஒரு பயனர் வடிவம் வழங்குகிறது.

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

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

     ஏற்றுமதி செயல்பாடு மாற்று (மாநில, ஐடி) {. }ஏற்றுமதி செயல்பாடு addTodo (மாநில, todo) {. }ஏற்றுமதி செயல்பாடு deleteTodo (மாநில, ஐடி) {. }    

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

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

TDD அல்லது TDD க்கு அல்லவா?

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

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

அறிமுகம் ஜஸ்ட்

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

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

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

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

     npm install -save-dev பாபல்- jest பாபல்- polyfill babel-preset-es2015 babel- முன்னமைக்கப்பட்ட-எதிர்வினை jest    

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

    "முன்னமைவு": ["es2015", "எதிர்வினை"]}    

நாம் எந்த Semalt சோதனை கருவிகளையும் நிறுவமாட்டோம், ஏனென்றால் எங்களது கூறுகளை சோதிப்போம், ஆனால் நமது மாநில செயல்பாடுகளைத் தொடங்குவோம்.

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

நாங்கள் எங்கள் மாநில செயல்பாடுகளை சோதிக்க வேண்டும் என, முன்னோக்கி சென்று __ நிலைகள் __ / மாநில செயல்பாடுகளை உருவாக்க. சோதனை. js .

Semalt விரைவில் ஒரு சரியான சோதனை எழுத, ஆனால் இப்போது, ​​இந்த போலி சோதனை வைத்து, எங்களுக்கு எல்லாம் சரி சரிபார்த்து விடுவோம் நாம் ஜஸ்ட் கட்டமைக்க வேண்டும்.

     விவரிக்கவும் ('கூட்டல்',    => {அது ('2 மற்றும் 2 செய்ய 4 என்று',    => {எதிர்பார்க்கிறேன் (2 + 2). வருங்கால  
;});});

இப்போது, ​​உங்கள் தொகுப்புக்கு தலை. ஜான்சன் .

     "ஸ்கிரிப்டுகள்": {"சோதனை": "நகைச்சுவை"}    

நீங்கள் இப்போது npm சோதனை இயங்கினால், உங்கள் சோதனைகளை ரன் பார்க்க வேண்டும், மற்றும் அனுப்ப!

     பாஸ் __ டெஸ்ட் __ / அரச சார்பில். சோதனை. JSகூடுதலாக✓ 2 மற்றும் 2 ஐ 4 (5 மீ)டெஸ்ட் தொகுதிகள்: 1 கழிந்தது, 1 மொத்தம்டெஸ்ட்: 1 வெற்றி, 1 மொத்தம்ஸ்னாப்ஷாட்ஸ்: 0 கழிந்தது, மொத்தம் 0நேரம்: 3. 11s    

நீங்கள் எப்போதாவது ஜாஸ்மின் அல்லது பெரும்பாலான சோதனை கட்டமைப்பைப் பயன்படுத்தியிருந்தால், மேலே உள்ள சோதனைக் குறியீடு தன்னை நன்கு அறிந்திருக்க வேண்டும். ஜஸ்ட் நாம் பயன்படுத்த வேண்டும் என 41 விவரிக்கிறது மற்றும் அது நாம் தேவைப்படும் கூடு சோதனைகள். நீங்கள் எவ்வளவு புத்திசாலித்தனம் செய்கிறீர்கள் என்பது உங்களுக்குத் தெரியுமா? நான் என் கூட்டை விரும்புகிறேன், எனவே அனைத்து விளக்கமான சரங்களும் மற்றும் 41 (அது 42) ஆகியவற்றை விவரிக்கிறது.

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

சோதனை வர்த்தக லாஜிக்

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

நீங்கள் இதைப் பின்தொடர்ந்தால், நீங்கள் repo ஐ க்ளோன் செய்து, உங்கள் 41 ___tests__ கோப்புறை கொண்டிருக்கும் அதே கோப்பகத்தில் பயன்பாட்டை கோப்புறை நகலெடுத்தீர்கள் என்பதை உறுதிப்படுத்தவும். நீங்கள் shortid தொகுப்பு npm install shortid - ssave ஐ நிறுவ வேண்டும், இது டோடோ பயன்பாட்டின் சார்பு.

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

உதாரணமாக, இங்கே நான் எவ்வாறு எழுத வேண்டும் என்பதையும் விவரிக்கிறது மற்றும் இது அழைப்புகள்:

     இலிருந்து 'toggleDone}. / பயன்பாட்டை / அரசு செயல்பாடுகளை ';விவரிக்கவும் ('toggleDone',    => {விவரிக்கவும் ('முழுமையடையாத தட்டு கொடுக்கப்பட்டபோது',    => {அது ('டூடோ முடிந்ததைக் குறிக்கிறது',    => {});});});    

இங்கே நான் அதை எப்படி செய்வேன் சோதனை :

     இலிருந்து 'toggleDone}. / பயன்பாட்டை / அரசு செயல்பாடுகளை ';test ('toggleDone ஒரு பூரணமற்ற டூடோவை நிறைவு செய்கிறது',    => {});    

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

இப்போது நாம் உறுதிப்படுத்தி எழுதலாம். முதலில் நாம் துவக்க நிலை உருவாக்க வேண்டும், அதை மாற்றுவதற்கு முன் , நாம் மாற்ற விரும்பும் டோடு என்ற ID உடன் இணைந்து. மாற்றுதல் எங்கள் பூரண நிலைக்குத் திரும்பும், பின் நாம் பின்வருமாறு உறுதிப்படுத்திக் கொள்ளலாம்:

     const starttate = {todos: [{id: 1, முடிந்தது: பொய், பெயர்: 'பால் வாங்க'}]};நிலையான finState = மாற்று மாற்று (தொடக்கநிலையானது, 1);எதிர்பார்க்கலாம் (finState. டாட்ஸ்). toEqual ([{id: 1, முடிந்தது: உண்மை, பெயர்: 'பால் வாங்க']);    

இப்போது நான் பயன்படுத்துவதை , ஈக்வாலை பயன்படுத்துவதை கவனிக்கவும். சரங்களை மற்றும் எண்களைப் போன்ற பழமையான மதிப்புகளில் toBe ஐ பயன்படுத்த வேண்டும், ஆனால் ஈக்வல் பொருள்கள் மற்றும் வரிசையில்.

இப்போது நாம் இப்போது npm சோதனை ரன் மற்றும் எங்கள் மாநில செயல்பாடு சோதனை பாஸ் பார்க்க:

     பாஸ் __ டெஸ்ட் __ / அரச சார்பில். சோதனை. JS✓ ஒரு முழுமையும் செய்யாத (9ms)டெஸ்ட் தொகுதிகள்: 1 கழிந்தது, 1 மொத்தம்டெஸ்ட்: 1 வெற்றி, 1 மொத்தம்ஸ்னாப்ஷாட்ஸ்: 0 கழிந்தது, மொத்தம் 0நேரம்: 3. 166s    

மாற்றங்கள் மீதான சோதனைகளை மீறுதல்

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

அதை கண்காணிப்பு முறையில் இயக்க, நீங்கள் npm சோதனை - --watch இயங்க முடியும். முதல் - க்கு பிறகு நீங்கள் npm சோதனை க்கு அனுப்பும் எந்தவொரு தகவலும் கீழ்க்கண்ட கட்டளைக்கு நேரடியாக அனுப்பப்படும். இதன் பொருள் என்னவென்றால், இந்த இரண்டு கட்டளைகள் சமமானவையாகும்:

  • npm சோதனை - - வாட்ச்
  • ஜஸ்ட் - வாட்ச்

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

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

என்னை சோதித்து பாருங்கள்

நீக்குதல் : :

இறக்குமதி செய்ய இறக்குமதியும்
     'toggleTodo, deleteTodo} இலிருந்து'. / பயன்பாட்டை / அரசு செயல்பாடுகளை ';     

இங்கு செமால்ட் எவ்வாறு சோதனை எழுதப்பட்டுள்ளது:

     சோதனை ('deleteTodo அது கொடுக்கப்பட்டால் தடுக்கிறது',    = & gt; {const start =todos: [{id: 1, முடிந்தது: பொய், பெயர்: 'பால் வாங்க'}]};const finState = deleteTodo (தொடக்கநிலையானது, 1);எதிர்பார்க்கலாம் (finState. டாட்ஸ்). toEqual ([]);});    

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

மேலே உள்ள சோதனைகள் ஒரு சோதனைக்கான சரியான அமைப்பை நிரூபிக்கின்றன:

  • அமைக்க
  • சோதனை கீழ் செயல்பாடு
  • முடிவுகளை உறுதிப்படுத்துகிறது.

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

இப்போது நாம் நமது மாநில செயல்பாடுகளை சோதித்து மகிழ்கிறோம், Semalt கூறுகளுக்கு செல்லலாம்.

பரிசோதிப்பு கூறுகள்

இது உங்கள் இயல்புநிலை கூறுகளில் பல சோதனைகள் எழுதத் தேவையில்லை என்று, உண்மையில், நான் உண்மையில் ஊக்குவிப்பேன் என்று குறிப்பிடுவது மதிப்பு. வணிகத் தர்க்கம் போன்ற, நீங்கள் முழுமையாக சோதிக்க விரும்பும் எதையுமே உங்கள் கூறுகளிலிருந்து வெளியேற்ற வேண்டும், நாங்கள் முன்னர் சோதித்த மாநில செயல்பாடுகளைப் போலவே தனித்துவமான செயல்பாட்டில் உட்கார வேண்டும். சில செமால்ட் பரஸ்பரங்களை சோதிக்க சில நேரங்களில் இது பயனுள்ளதாக இருக்கும் (பயனர் ஒரு பொத்தானை சொடுக்கும் போது, ​​ஒரு குறிப்பிட்ட செயல்பாடு சரியான வாதங்களுடன் அழைக்கப்படுவதை உறுதிப்படுத்துகிறது). எங்கள் செமால்ட் கூறுகள் சரியான தரவை அளிக்கின்றன என்பதை பரிசோதிப்பதன் மூலம் தொடங்குவோம், பின்னர் சோதனை இடைவெளிகளை பாருங்கள். பின்னர் நாம் ஸ்னாப்ஷாட்டிற்கு செல்லலாம், ஜெஸ்டின் ஒரு அம்சம், இது Semalt கூறுகளின் வெளியீட்டை மிகவும் வசதியாக சோதனை செய்கிறது. நாங்கள் சோதனை செய்யும் ஏஎஸ்பிஎன்பி மூலம் எழுதப்பட்ட மினு நூலகம் என்ஸைம் நிறுவும். எங்கள் சோதனைகளில் இந்த API ஐ பயன்படுத்துவோம். என்சைம் ஒரு அற்புதமான நூலகம், மற்றும் பதில் குழு கூட கூறுகள் சோதனை சோதிக்க வழி இது பரிந்துரைக்கிறோம்.

     npm நிறுவ - ssave-dev பிரதிபலிப்பு- addons-test-utils என்சைம்    

நாம் டோடோ பாகம் ஒரு பத்தியில் அதன் தொனியில் உரை வழங்குகிறது என்று சோதிக்க வேண்டும். முதலில் நாம் உருவாக்க வேண்டும் __tests __ / todo. சோதனை. js , மற்றும் எங்கள் கூறு இறக்குமதி:

     டடோ இருந்து 'இறக்குமதி. / பயன்பாட்டை / செய்ய ';இறக்குமதி 'பிரதிபலிப்பு' இருந்து பதில்;'என்சைம்' இலிருந்து இறக்குமதி {mount};சோதனை ('டோடோ கூறு' todo ',    => {});    

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

டோடோ :

     const toto = {id: 1, செய்யப்பட்டது: பொய், பெயர்: 'பால் வாங்க');const wrapper = ஏற்ற (  );    

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

     const p = ரப்பர். கண்டுபிடி ('மாற்று மாற்று');    

இறுதியாக, அதில் உள்ள உரை பால் வாங்கவும் :

     எதிர்பார்க்கலாம் (ப) உரை. toBe ('பால் வாங்க');    

சிமால்ட் எங்கள் முழு சோதனை விட்டு போல:

     டடோ இருந்து 'இறக்குமதி. / பயன்பாட்டை / செய்ய ';இறக்குமதி 'பிரதிபலிப்பு' இருந்து பதில்;'என்சைம்' இலிருந்து இறக்குமதி {mount};சோதனை ('TodoComponent உள்ளே உரை வழங்குவது',    => {constto todo = {id: 1, done: false, name: 'milk வாங்க'};const wrapper = ஏற்ற (  );const p = ரப்பர். கண்டுபிடி ('மாற்று மாற்று');எதிர்பார்ப்பது (ப. உரை   ). toBe ('பால் வாங்க');});    

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

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

இந்த சோதனையில் நாம் டோடோ சொடுக்கும் போது, ​​உறுப்பு என்று அழைக்கப்படும் மாற்று ப்ராப் என்று அழைக்கப்படும்.

     சோதனை ('டோடோ அழைப்புகள் செய்யப்பட்டது போதாதபோது மாற்றலாம்',    => {});    

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

     const doneChange = jest. எஃப்என்   ;    

இது நாம் உளவு மற்றும் அதை சரியாக என்று உறுதி செய்ய முடியும் என்று ஒரு செயல்பாடு கொடுக்கிறது. எஃப்என் ;const wrapper = ஏற்ற ( );

அடுத்து, முந்தைய பத்தியில் உள்ளதைப் போல மீண்டும் நம் பத்தியைக் காணலாம்:

     const p = டெஸ்டுலிஸ். findRenderedDOMComponentWithClass (மொழிபெயர்க்கப்பட்ட, 'toggle-todo');    

பின்னர் ஒரு பயனர் நிகழ்வை உருவகப்படுத்தி உருவகப்படுத்தி கிளிக் வாதம் என அழைக்கலாம்:

     ப. ( 'கிளிக்') உருவகப்படுத்த;    

மற்றும் செய்ய வேண்டிய அனைத்தும் எங்கள் உளவு செயல்பாடு சரியாக அழைக்கப்படுகிறது என்று உறுதியாக உள்ளது. இந்த வழக்கில், நாங்கள் அதை 1 என்பது டூடோவின் அடையாளத்துடன் அழைக்கப்பட வேண்டும் என்று எதிர்பார்க்கிறோம். நாம் எதிர்பார்க்கலாம் (முடிந்தது). toBeCalledWith இதை உறுதிப்படுத்துவதோடு, நமது சோதனை முடிந்துவிட்டோம்!

     சோதனை ('டோடோ உரிம அழைப்புகள் செய்யப்பட்டது போதாதபோது மாற்றலாம்',    => {constto todo = {id: 1, done: false, name: 'milk வாங்க'};const. செய்யப்பட்டது = jest. எஃப்என்   ;const wrapper = ஏற்ற (  );const p = ரப்பர். கண்டுபிடி ('மாற்று மாற்று');ப. ( 'கிளிக்') உருவகப்படுத்த;எதிர்பார்க்க (doneChange). toBeCalledWith   ;});    

ஸ்னாப்சோட்களுடன் சிறந்த உபகரண சோதனை

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

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

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

சோதனை இந்த வழி என்று பொருள்:

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

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

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

     npm நிறுவ - ssave-dev பிரதிபலிப்பு-சோதனை-ரெண்டரர்    

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

நீங்கள் செய்ய வேண்டிய முதல் விஷயம், எதிர்-சோதனை-ரெண்டரர் ஐ இறக்குமதி செய்து, ஏற்ற க்கான இறக்குமதியை நீக்கவும். அவர்கள் இருவரும் பயன்படுத்த முடியாது; நீங்கள் ஒன்று அல்லது மற்றொன்று பயன்படுத்த வேண்டும். இதனாலேயே, மற்ற சோதனை இப்போது நாம் கருத்து தெரிவித்திருக்கிறோம். உருவாக்க ( );எதிர்பார்ப்பது (toJSON ). toMatchSnapshot ;});});

முதல் முறையாக நீங்கள் இதை இயக்கும் போது, ​​இந்த கூறுக்கு எவ்வித ஸ்னாப்ஷாட் இல்லை என்பதை உணருவதற்கு ஜஸ்ட் புத்திசாலி, அதனால் அதை உருவாக்குகிறது. நாம் பார்க்கலாம் __tests __ / __ ஸ்னாப்ஷாட்ஸ் __ / todo. சோதனை. JS. படம் :

     ஏற்றுமதி [Todo component சரியாக சரியாக வழங்குவது சரியாக வழங்குவது 1`] = ` <கிராமclassName = "todo todo-1">  <பclassname = "மாற்று-செய்ய"onclick = {[விழா]}> பால் வாங்கவும் 

<ஒருclassname = "நீக்க-செய்ய"href = "#"onclick = {[விழா]}> அழி
`;

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

March 1, 2018