Back to Question Center
0

એકમ Mocha અને ચાઇ મદદથી તમારા જાવાસ્ક્રિપ્ટ પરીક્ષણ            એકમ Mocha અને Chai જોડાયેલ વિષયો ઉપયોગ કરીને તમારા જાવા પરીક્ષણ: એન્ગલરજેએસઇએસઇએસઇ 6 રવા મીમલ્ટ

1 answers:
એકમ Mocha અને ચાઇ મદદથી તમારા જાવાસ્ક્રિપ્ટ પરીક્ષણ

આ લેખમાં પિયાનોઈટીસ «પીવીઆરજી» વેલિસારકોસ, માર્ક બ્રાઉન અને ટોમ ગ્રીકો દ્વારા પીઅરની સમીક્ષા કરવામાં આવી હતી. સેમ્ટટ સામગ્રી બનાવવા માટે સેમલ્ટના પીઅર સમીક્ષકોનો આભાર, તે શ્રેષ્ઠ હોઈ શકે છે!

શું તમે ક્યારેય તમારા કોડમાં કેટલાક ફેરફારો કર્યાં છે, અને પછીથી તેને કંઈક તોડવા માટે કંઈક થયું છે?

ખાતરી કરો કે અમારામાંથી મોટાભાગના લોકો પાસે છે. આ લગભગ અનિવાર્ય છે, ખાસ કરીને જ્યારે તમારી પાસે મોટા પ્રમાણમાં કોડ છે એક વસ્તુ બીજા પર નિર્ભર કરે છે, અને પછી તેને બદલીને પરિણામે કંઈક બીજું તોડે છે.

પણ જો આવું ન થાય તો શું? કેટલાક ફેરફારના પરિણામ સ્વરૂપે કંઈક તોડે છે તે જાણીને તમને શું કરવું જોઈએ? તે ખૂબ સરસ હશે. તમે કાંઇ ભાંગવાની ચિંતા કર્યા વગર તમારો કોડ સુધારી શકો છો, તમારી પાસે ઓછા ભૂલો હશે અને તમે ઓછો સમય ડિબગીંગ કરશો

કે જ્યાં એકમ પરીક્ષણો ચમકે છે. તેઓ આપોઆપ તમારા માટે કોડમાં કોઈ સમસ્યા શોધશે - private transportunternehmen. ફેરફાર કરો, તમારા પરીક્ષણો ચલાવો અને જો કોઈ તૂટ્યું હોય, તો તમને તરત જ ખબર પડશે કે શું થયું, સમસ્યા ક્યાં છે અને યોગ્ય વર્તન શું હોવું જોઈએ આ સંપૂર્ણપણે કોઈપણ અનુમાનિત કાર્યને દૂર કરે છે!

આ લેખમાં, હું તમને બતાવીશ કે તમારા જાવાસ્ક્રીપ્ટ કોડની ચકાસણી કેવી રીતે કરવી. આ લેખમાં બતાવેલ ઉદાહરણો અને તકનીકો બંને બ્રાઉઝર-આધારિત કોડ અને મીમલ્ટ કોડ પર લાગુ થઈ શકે છે.

આ ટ્યુટોરીયલનો કોડ અમારા સેમલ્ટ રેપોથી ઉપલબ્ધ છે.

એકી ટ્રિનિટીંગ શું છે

જ્યારે તમે તમારા કોડબેઝની ચકાસણી કરો છો, તમે કોડનો એક ભાગ લો છો - સામાન્ય રીતે કાર્ય - અને ચોક્કસ પરિસ્થિતિમાં તે યોગ્ય રીતે વર્તે છે તેની ચકાસણી કરો. એકમ પરીક્ષણ એ આ કરવા માટેની ગોઠવણ અને સ્વચાલિત રીત છે. પરિણામે, તમે જે વધુ પરીક્ષણો લખો છો, તે તમને મળતો લાભ તમે તમારા કોડબેઝમાં પણ વિશ્વાસનો મોટો સ્તર ધરાવો છો, કારણ કે તમે તેનો વિકાસ ચાલુ રાખો છો.

એકમ પરીક્ષણ સાથેના મૂળ વિચાર એ ફંક્શનનું વર્તન ચકાસવા માટે છે જ્યારે તે ચોક્કસ પ્રકારના ઇનપુટ્સ આપે છે. તમે ચોક્કસ પરિમાણો સાથે એક કાર્ય કૉલ કરો છો, અને તપાસો કે સાચો પરિણામ મળ્યું છે.

     // આપેલ 1 અને 10 ઇનપુટ્સ તરીકે var પરિણામ = મઠ મહત્તમ (1, 10);// . આપણે આઉટપુટ તરીકે 10 પ્રાપ્ત કરીશુંજો (પરિણામ! == 10) {નવી ભૂલ ('નિષ્ફળ') ફેંકવું;}    

વ્યવહારમાં, પરીક્ષણો ઘણીવાર વધુ જટિલ બની શકે છે ઉદાહરણ તરીકે, જો તમારું કાર્ય એજેક્સ વિનંતી કરે છે, તો પરીક્ષણ માટે વધુ સેટ અપની જરૂર છે, પરંતુ "ચોક્કસ ઇનપુટ આપવામાં આવે છે, અમે ચોક્કસ પરિણામની અપેક્ષા રાખીએ છીએ" નું એ જ સિદ્ધાંત હજુ પણ લાગુ પડે છે.

ટૂલ્સ સેટિંગ

આ લેખ માટે, અમે Mocha નો ઉપયોગ કરીશું. પ્રારંભ કરવું સરળ છે, તે બ્રાઉઝર-આધારિત પરીક્ષણ અને સેમિટેક પરીક્ષણ બંને માટે ઉપયોગમાં લઈ શકાય છે, અને તે અન્ય પરીક્ષણ સાધનો સાથે સરસ રીતે ભજવે છે.

મોચા સ્થાપિત કરવાનો સૌથી સરળ માર્ગ એ એનપીએમ મારફતે છે (જેના માટે આપણે નોડને સ્થાપિત કરવાની જરૂર છે. જો તમે તમારી સિસ્ટમ પર ક્યાં તો એનપીએમ અથવા નોડ કેવી રીતે સ્થાપિત કરવું તે બાબતે અનિશ્ચિત હોવ તો, અમારા ટ્યુટોરીયલનો સંપર્ક કરો: એ પ્રારંભિક માર્ગદર્શિકા npm - નોડ પેકેજ મેનેજર

નોડ સાથે સ્થાપિત, તમારા પ્રોજેક્ટની ડિરેક્ટરીમાં ટર્મિનલ અથવા આદેશ વાક્ય ખોલો.

  • જો તમે બ્રાઉઝરમાં કોડ ચકાસવા માંગો છો, તો ચલાવો npm સ્થાપિત મોચા ચાઇ --save-dev
  • જો તમે નોડ ચકાસવા માંગો છો જેએસ કોડ, ઉપરોક્ત ઉપરાંત ચલાવો npm સ્થાપિત-જી મોચા

આ પેકેજો સ્થાપિત કરે છે મોચા અને ચાઇ . મોચા એ લાઇબ્રેરી છે જે અમને પરીક્ષણો ચલાવવા માટે પરવાનગી આપે છે, અને ચાઇમાં કેટલાક ઉપયોગી કાર્યો છે જે અમે અમારા પરીક્ષણ પરિણામો ચકાસવા માટે ઉપયોગ કરીશું.

નોડ પર પરીક્ષણ. બ્રાઉઝરમાં જેએસ વિ ટેસ્ટિંગ

બ્રાઉઝરમાં પરીક્ષણો ચલાવી રહ્યા હોય તો તે અનુસરો તે ઉદાહરણો કામ કરવા માટે રચાયેલ છે. જો તમે તમારા મીમોલ્ટ એપ્લિકેશનને એકમ કરવા માંગો છો, તો આ પગલાંઓનું પાલન કરો

  • નોડ માટે, તમારે ટેસ્ટ રનર ફાઇલની જરૂર નથી.
  • બ્રાઉઝર ખોલવાને બદલે મોચા આદેશનો ઉપયોગ કરીને પરીક્ષણો ચલાવો.

ડાયરેક્ટરી સ્ટ્રક્ચર સ્થાપવું

તમારે તમારા પરીક્ષણોને તમારી મુખ્ય કોડ ફાઇલોથી અલગ ડિરેક્ટરીમાં મૂકવો જોઈએ. આનાથી તેને સરળ બનાવવા માટે તે સરળ બનાવે છે, ઉદાહરણ તરીકે જો તમે ભવિષ્યમાં અન્ય પ્રકારના પરીક્ષણો ઉમેરવા માંગતા હો (જેમ કે સંકલન પરીક્ષણો અથવા વિધેયાત્મક પરીક્ષણો).

જાવાસ્ક્રીપ્ટ કોડ સાથેની સૌથી પ્રચલિત પ્રથા તમારા પ્રોજેક્ટની રૂટ ડાયરેક્ટરીમાં ટેસ્ટ / ડિરેક્ટરી હોવી જોઈએ. પછી, દરેક પરીક્ષણ ફાઇલ પરીક્ષણ / અમુક મોડ્યુલટેસ્ટ હેઠળ મૂકવામાં આવે છે. જેએસ વૈકલ્પિક રીતે, તમે ટેસ્ટ / અંદરની ડિરેક્ટરીઓનો ઉપયોગ પણ કરી શકો છો, પણ હું વસ્તુઓને સરળ રાખવા ભલામણ કરું છું - જો જરૂરી હોય તો પછી તમે તેને હંમેશા બદલી શકો છો

એક ટેસ્ટ રનર સુયોજિત

બ્રાઉઝરમાં અમારા પરીક્ષણો ચલાવવા માટે, અમારે ટેસ્ટ રનર પૃષ્ઠ બનવા માટે એક સરળ HTML પૃષ્ઠ સેટ કરવાની જરૂર છે આ પાનું લોડ Mocha, પરીક્ષણ પુસ્તકાલયો અને અમારી વાસ્તવિક ટેસ્ટ ફાઈલો. પરીક્ષણો ચલાવવા માટે, અમે ફક્ત એક બ્રાઉઝરમાં રનર ખોલીશું.

જો તમે નોડનો ઉપયોગ કરી રહ્યાં છો જેએસ, તમે આ પગલું અવગણી શકો છો. નોડ જેએસ એકમ પરીક્ષણો આદેશ મોચા નો ઉપયોગ કરીને ચલાવી શકાય છે, એમ ધારી રહ્યા છીએ કે તમે આગ્રહણીય ડિરેક્ટરી માળખું અનુસર્યું છે.

નીચેનો કોડ અમે ટેસ્ટ રનર માટે ઉપયોગ કરીશું. હું આ ફાઈલને ટેસ્ટરનર તરીકે સાચવીશ. html

    મોચા ટેસ્ટ </ title><link rel = "સ્ટાઇલશીટ" href = "node_modules / mocha / mocha. css"></ head><body><div id = "મોચા">  </div> <script src = "node_modules / mocha / mocha. js"> </ script><script src = "node_modules / chai / chai. js"> </ script><સ્ક્રિપ્ટ> મોચા સેટઅપ ('bdd') </ script><! - લોડ કોડ તમે અહીં ચકાસવા માંગો છો -><! - તમારી ટેસ્ટ ફાઇલો અહીં લોડ કરો -><script>મોચા રન  <span class="f-c-white l-mr3"> ;</ script></ body></ html> </code>   </pre>  <p>  ટેસ્ટ રનર માં મહત્વપૂર્ણ બીટ્સ છે:  </p>  <ul>  <li>  અમે અમારી પરીક્ષણ પરિણામો સરસ ફોર્મેટિંગ આપવા માટે Mocha માતાનો સીએસએસ શૈલીઓ લોડ.  </li>  <li>  અમે આઈડી સાથે એક div બનાવો  <code>  મોચા  </code> . આ તે છે જ્યાં પરીક્ષણ પરિણામો શામેલ કરવામાં આવે છે.  </li>  <li>  અમે મોચા અને ચાઈ લોડ કરીએ છીએ. તેઓ  <code>  નોડ_ મોડોડ્સ  </code>  ફોલ્ડરના સબફોલોલ્ડર્સમાં સ્થિત છે કારણ કે અમે તેમને npm મારફતે સ્થાપિત કર્યું છે.  </li>  <li>  બોલાવીને  <code>  મોચા સેટઅપ  </code> , અમે Mocha માતાનો પરીક્ષણ મદદગારો ઉપલબ્ધ બનાવે છે  </li>  <li>  તે પછી, અમે પરીક્ષણ કોડ અને ટેસ્ટ ફાઇલોને લોડ કરીએ છીએ. અમારી પાસે હજી સુધી અહીં કંઈપણ નથી.  </li>  <li>  છેલ્લે, અમે  <code>  મોચા કહીએ છીએ પરીક્ષણો ચલાવવા માટે  </code>  રન કરો. ખાતરી કરો કે તમે આને  <em>  પછી  </em>  સ્રોત અને પરીક્ષણ ફાઇલો લોડ કરી રહ્યાં છો.  </li>  </ul> <h2 id="the-basic-test-building-blocks"> મૂળભૂત ટેસ્ટ બિલ્ડિંગ બ્લોક્સ  </h2>  <p>  હવે આપણે પરીક્ષણો ચલાવી શકીએ, ચાલો આપણે કેટલાક લખવાનું શરૂ કરીએ.  </p>  <p>  અમે નવી ફાઇલ બનાવીને શરૂ કરીશું  <code>  test / arrayTest જેએસ  </code>  આની જેમ એક વ્યક્તિગત પરીક્ષણ ફાઇલને  <em>  ટેસ્ટ કેસ  </em>  તરીકે ઓળખવામાં આવે છે. હું તેને કૉલ કરું છું  <code>  એરેટીસ્ટ જેએસ  </code>  કારણ કે આ ઉદાહરણ માટે, અમે કેટલીક મૂળભૂત એરે કાર્યક્ષમતા પરીક્ષણ કરીશું.  </p>  <p>  દરેક ટેસ્ટ કેસ ફાઇલ સમાન પાયાની પેટર્ન અનુસરે છે. પ્રથમ, તમારી પાસે  <code>  વર્ણન  </code>  બ્લોક છે:  </p>  <pre>   <code>  વર્ણન ('અરે', કાર્ય  <span class="f-c-white l-mr3">  {// ટેસ્ટ માટે વધુ કોડ અહીં જાય છે}); </code>   </pre>  <p>   <code>  વર્ણન  </code>  વ્યક્તિગત પરીક્ષણો જૂથ માટે વપરાય છે. પ્રથમ પરિમાણો સૂચવશે કે આપણે શું ચકાસી રહ્યા છીએ - આ કિસ્સામાં, કારણ કે આપણે એરે વિધેયોની ચકાસણી કરવા જઈ રહ્યા છીએ, મેં શબ્દમાળા  <code>  'અરે'  </code>  માં પસાર કર્યો છે.  </p>  <p>  બીજું,  <code>  ની અંદર  </code>  વર્ણન  </code> , અમારી પાસે  <code>  તે  </code>  બ્લોક્સ હશે:  </p>  <pre>   <code>  વર્ણન ('અરે', કાર્ય  <span class="f-c-white l-mr3">  {તે ('ખાલી થવું જોઈએ', કાર્ય  <span class="f-c-white l-mr3">  {// ટેસ્ટ અમલીકરણ અહીં જાય છે});// આપણે અહીં વધુ કરી શકીએ છીએ}); </code>   </pre>  <p>   <code>  તે  </code>  વાસ્તવિક પરીક્ષણો બનાવવા માટે વપરાય છે. પ્રથમ પરિમાણ  <code>  તે  </code>  પરીક્ષાનું માનવ વાંચનીય વર્ણન પૂરું પાડવું જોઈએ. ઉદાહરણ તરીકે, આપણે ઉપરોક્ત વાંચી શકીએ છીએ કે તે "ખાલી શરૂ કરવું જોઈએ", જે એરે કેવી રીતે વર્તવું જોઈએ તે સારું વર્ણન છે.  </p>  <p>  બધા સેમીટ ટેસ્ટ આ બિલ્ડીંગ બ્લોકોમાંથી બનાવવામાં આવ્યા છે, અને તેઓ આ જ મૂળભૂત પેટર્નનું અનુસરણ કરે છે.  </p>  <ul>  <li>  સૌપ્રથમ, અમે  <code>  વર્ણન કરીએ છીએ  </code>  કહેવા માટે કે આપણે શું પરીક્ષણ કરી રહ્યા છીએ - ઉદાહરણ તરીકે, "વર્ણવે છે કે કેવી રીતે એરે કાર્ય કરવું જોઈએ".  </li>  <li>  પછી, અમે  <div class="widget maestro maestro-content-type-html hide-for-mobile-SP" id="maestro-659">  વ્યક્તિગત પરીક્ષણો બનાવવા માટે  <code>  કાર્ય  </code>  નો ઉપયોગ કરીએ - દરેક  <code>  તે  </code>  એક વિશિષ્ટ વર્તણૂક સમજાવવું જોઈએ, જેમ કે અમારા એરે કેસ માટે "તે ખાલી શરૂ કરવું જોઈએ" ઉપર  </li>  </ul> <h2 id="writing-the-test-code"> ટેસ્ટ કોડ લેખન  </h2>  <p>  હવે અમે પરીક્ષણ કેસ માળખું કેવી રીતે ખબર છે કે, ચાલો આનંદ ભાગ માં બાંધી - પરીક્ષણ અમલીકરણ.  </p>  <p>  મીમલ્ટ અમે ચકાસી રહ્યા છીએ કે એરે ખાલી શરૂ થવું જોઈએ, અમારે એરે બનાવવાની જરૂર છે અને પછી તે ખાલી છે તેની ખાતરી કરો. આ પરીક્ષાની અમલીકરણ એકદમ સરળ છે:  </p>  <pre>   <code>  વાર આગ્રહ = ચાઇ ભારપૂર્વક જણાવે છે;વર્ણન કરો ('અરે', કાર્ય  <span class="f-c-white l-mr3">  {તે ('ખાલી થવું જોઈએ', કાર્ય  <span class="f-c-white l-mr3">  {var arr = [];ભારપૂર્વક જણાવે છે સમાન (એઆર લંબાઈ, 0);});}); </code>   </pre>  <p>  પ્રથમ વાક્ય પર નોંધ કરો, આપણે  <code>  ભારપૂર્વક  </code>  વેરિયેબલ સુયોજિત કરીએ છીએ. આ એટલા માટે છે કે આપણને ટાઈપ રાખવાની જરૂર નથી  <code>  ચાઇ ભારપૂર્વક જણાવે છે  </code>  સર્વત્ર.  </p>  <p>  માં  <code>  તે  </code>  કાર્ય, અમે એક એરે બનાવો અને તેની લંબાઈ તપાસો. સરળ હોવા છતાં, આ પરીક્ષણો કેવી રીતે કાર્ય કરે છે તેનું એક સારું ઉદાહરણ છે.  </p>  <p>  પ્રથમ, તમારી પાસે કંઈક છે જે તમે પરીક્ષણ કરી રહ્યાં છો - આને  <em>  સિસ્ટમ ટેસ્ટ હેઠળ  </em>  અથવા  <em>  સુટ  </em>  કહેવામાં આવે છે. પછી, જો જરૂરી હોય તો, તમે SUT સાથે કંઈક કરો છો. આ કસોટીમાં, આપણે કાંઇ નથી કરી રહ્યા છીએ, કારણ કે આપણે એરે તપાસ કરી રહ્યા છીએ ખાલી શરુ થાય છે.  </p>  <p>  પરીક્ષામાં છેલ્લી વસ્તુ માન્યતા હોવી જોઇએ - એક  <em>  દાવા  </em>  જે પરીણામની તપાસ કરે છે. અહીં, અમે ઉપયોગ કરી રહ્યા છીએ  <code>  ભારપૂર્વક જણાવે છે. આમ કરવા માટે સમાન  </code>  મોટા ભાગના દાવા કાર્યો તે જ ક્રમમાં પરિમાણો લે છે: પ્રથમ "વાસ્તવિક" મૂલ્ય, અને પછી "અપેક્ષિત" મૂલ્ય.  </p>  <ul>  <li>  ધ  <em>  વાસ્તવિક  </em>  કિંમત તમારા પરીક્ષણ કોડ પરિણામ છે, તેથી આ કિસ્સામાં  <code>  arr. લંબાઈ  </code>  </li>  <li>  ધ  <em>  અપેક્ષિત  </em>  મૂલ્ય પરિણામ છે  <em>  શું  </em>  હશે એરે ખાલી ખાલી થવાથી, આ ટેસ્ટમાં અપેક્ષિત મૂલ્ય છે  <code>  0  </code>  </li>  </ul>  <p>  ચાઈ પણ લેખિત દાવાઓની બે અલગ અલગ શૈલીઓ પ્રસ્તુત કરે છે, પરંતુ અમે હવે વસ્તુઓને સરળ રાખવા માટેનો ઉપયોગ કરી રહ્યા છીએ. જ્યારે તમે લેખન પરીક્ષણો સાથે વધુ અનુભવી બની શકો છો, ત્યારે તમે તેના બદલે વધુ ધારણાઓનો ઉપયોગ કરવા માગી શકો, કારણ કે તેઓ વધુ રાહત આપે છે.  </p> <h2 id="running-the-test"> ટેસ્ટ ચલાવવું  </h2>  <p>  આ કસોટી ચલાવવા માટે, આપણે પહેલા બનાવેલ ટેસ્ટ રનર ફાઈલમાં તેને ઉમેરવાની જરૂર છે.  </p>  <p>  જો તમે નોડનો ઉપયોગ કરી રહ્યાં છો જેએસ, તમે આ પગલું અવગણી શકો છો, અને ટેસ્ટ ચલાવવા માટે આદેશ  <code>  મોચા  </code>  નો ઉપયોગ કરી શકો છો. તમે ટર્મિનલમાં પરીક્ષણ પરિણામો જોશો.  </p>  <p>  મીમોલ્ટ, આ ટેસ્ટ રનરને ઉમેરવા માટે, ફક્ત ઉમેરો:  </p>  <pre>   <code>  <script src = "test / arrayTest. Js"> </ script> </code>   </pre>  <p>  નીચે:  </p>  <pre>   <code>  <! - તમારી ટેસ્ટ ફાઇલો અહીં લોડ કરો -> </code>   </pre>  <p>  એકવાર તમે સ્ક્રિપ્ટ ઉમેરાયા પછી, તમે પસંદગીના તમારા બ્રાઉઝરમાં ટેસ્ટ રનર પૃષ્ઠ લોડ કરી શકો છો.  </p>  <h2 id="the-test-results">  ટેસ્ટ પરિણામો  </h2>  <p>  જ્યારે તમે તમારા પરીક્ષણો ચલાવો છો, ત્યારે પરીક્ષણ પરિણામો આના જેવી દેખાશે:  </p>  <p>   <img src="/img/d4088f278b6ea3753bead38d065707700.jpg" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <p>  નોંધ કરો કે આપણે  <code>  વર્ણન  </code>  અને  <code>  તે  </code>  વિધેયો આઉટપુટમાં બતાવ્યા છે - પરીક્ષણો વર્ણન હેઠળ જૂથ થયેલ છે. નોંધ કરો કે માળામાં  <code>  વર્ણન કરવા માટે પણ શક્ય છે  </code>  બ્લોકો વધુ પેટા જૂથો બનાવવા માટે.  </p>  <p>  મીમોલ્ટ એ તપાસ કરો કે નિષ્ફળતાની કસોટી કેવી દેખાય છે.  </p>  <p>  કસોટીમાં લીટી પર જે કહે છે:  </p>  <pre>   <code>  ભારપૂર્વક જણાવે છે. સમાન (એઆર લંબાઈ, 0); </code>   </pre>  <p>  નંબર  <code>  0  </code>  સાથે  <code>  1  </code>  બદલો. આનાથી ટેસ્ટ નિષ્ફળ થાય છે, કારણ કે એરેની લંબાઈ અપેક્ષિત મૂલ્ય સાથે બંધબેસે નહીં.  </p>  <p>  જો તમે ફરીથી પરીક્ષણો ચલાવો છો, તો તમને ખોટું થયું હોવાના વર્ણન સાથે લાલમાં નિષ્ફળ પરીક્ષા દેખાશે. અમે તેને ઠીક કરી શકીએ છીએ.  </p>  <p>  મોટા ભાગના દાવા વિધેયો વૈકલ્પિક  <code>  મેસેજ  </code>  પેરામીટર લઈ શકે છે. આ એવો સંદેશ છે જે રજૂઆત નિષ્ફળ જાય ત્યારે પ્રદર્શિત થાય છે. ભૂલ સંદેશો સમજવા માટે સરળ બનાવવા માટે આ પેરામીટરનો ઉપયોગ કરવાનું એક સારું વિચાર છે.  </p>  <p>  અમે આ પ્રમાણે અમારા દાવા માટે સંદેશ ઉમેરી શકીએ છીએ:  </p>  <pre>   <code>  ભારપૂર્વક જણાવે છે. સમાન (એઆર લંબાઈ, 1, 'અરે લંબાઈ 0 ન હતી'); </code>   </pre>  <p>  જો તમે પરીક્ષણો ફરીથી ચલાવો છો, તો ડિફોલ્ટની જગ્યાએ કસ્ટમ મેસેજ દેખાશે.  </p>  <p>  ચાલો આપણે જે રીતે કહીએ તેમાં પાછા ફેરબદલ કરીએ -  <code>  1  </code>  સાથે  <code>  0  </code>  સાથે બદલો, અને ખાતરી કરો કે તેઓ પસાર થાય તે માટે ફરીથી પરીક્ષણો ચલાવો.  </p> <h2 id="putting-it-together"> તે પુટિંગ સાથે  </h2>  <p>  અત્યાર સુધીમાં આપણે એકદમ સરળ ઉદાહરણો જોયાં છે. સેમ્યુઅલએ અમે જે સિદ્ધાંતમાં શીખ્યા છીએ તે જુઓ અને જુઓ કે અમે કોડના વધુ વાસ્તવિક ભાગની કસોટી કેવી રીતે કરીશું.  </p>  <p>  અહીં એક ફંક્શન છે જે એક ઘટકમાં CSS વર્ગ ઉમેરે છે. આ નવી ફાઇલમાં જવું જોઈએ  <code>  જેએસ / વર્ગ નામ જેએસ  </code>   </p>  <pre>   <code>  ફંક્શન ઍડક્લાસ (અલ, નવો ક્લાસ) {if (el. className. indexOf (newClass) === -1) {અલ className + = newClass;}} </code>   </pre>  <p>  તેને થોડી વધુ રસપ્રદ બનાવવા માટે, મેં તેને એક નવું વર્ગ ઉમેર્યું જ્યારે તે વર્ગ એક તત્વ  <code>  ક્લાસમેન  </code>  પ્રોપર્ટીમાં અસ્તિત્વમાં ન હોય - જે જોવા માંગે છે  <code>  <div class = " હેલ્લો હેલો હેલો હેલો ">  </code>  બધા પછી?  </p>  <p>  શ્રેષ્ઠ કિસ્સામાં, અમે આ કાર્ય માટે પરીક્ષણો લખીશું  <em>  પહેલાં  </em>  આપણે કોડ લખીએ છીએ પરંતુ પરીક્ષણ આધારિત વિકાસ એક જટિલ વિષય છે, અને હવે અમે ફક્ત લેખન પરીક્ષણો પર ધ્યાન કેન્દ્રિત કરવા માંગીએ છીએ.  </p>  <p>  પ્રારંભ કરવા માટે, ચાલો એકમ પરીક્ષણો પાછળના મૂળભૂત વિચારને યાદ કરીએ: અમે કાર્યને ચોક્કસ ઇનપુટ આપીએ છીએ અને પછી કાર્યની ખાતરી કરો કે અપેક્ષિત તરીકે વર્તે છે. તો આ ફંક્શન માટે ઇનપુટ્સ અને વર્તણૂકો શું છે?  </p>  <p>  એક તત્વ અને ક્લાસનું નામ:  </p>  <ul>  <li>  જો તત્વ  <code>  ક્લાસમેનમ  </code>  પ્રોપર્ટીમાં ક્લાસ નામ હોતું નથી, તો તેને ઉમેરવું જોઈએ.  </li>  <li>  જો તત્વ  <code>  ક્લાસમેનમ  </code>  પ્રોપર્ટીમાં ક્લાસ નામ હોવું જોઈએ, તો તેને ઉમેરવું જોઈએ નહીં.  </li>  </ul>  <p>  ચાલો આ કેસોને બે પરીક્ષણોમાં અનુવાદ કરીએ.  <code>  ટેસ્ટ  </code>  ડિરેક્ટરીમાં, નવી ફાઇલ બનાવો  <code>  classNameTest જેએસ  </code>  અને નીચેનો ઉમેરો:  </p>  <pre>   <code>  વર્ણવે છે ('addClass', કાર્ય  <span class="f-c-white l-mr3">  {તે ('તત્વને વર્ગ ઉમેરવી જોઈએ');તે ('એક વર્ગ ઉમેરવો જોઈએ નહીં કે જે પહેલેથી હાજર છે');}); </code>   </pre>  <p>  અમે શબ્દોથી તેને સહેજ "બદલવું જોઈએ" ફોર્મમાં પરીક્ષણો સાથે ઉપયોગ કર્યો છે. આનો અર્થ એ થાય કે તે થોડી સારી રીતે વાંચે છે, પરંતુ આવશ્યકપણે તે જ માનવ વાંચનીય ફોર્મ છે જે અમે ઉપર સૂચિબદ્ધ કર્યું છે. વિચારને ચકાસવા માટે સામાન્ય રીતે મીઠું આ કરતાં વધુ મુશ્કેલ નથી.  </p>  <p>  પરંતુ રાહ જુઓ, ટેસ્ટ કાર્ય ક્યાં છે? ઠીક છે, જ્યારે આપણે બીજા પરિમાણને  <code>  તે  </code>  અવગણીએ છીએ, તો મોચા આ પરીક્ષણોને પરીક્ષણોના પરિણામોમાં  <em>  બાકી  </em>  ચિહ્નિત કરે છે. આ સંખ્યાબંધ પરીક્ષણો સેટ કરવાની એક સાનુકૂળ રીત છે - તમે જે લખવાનો ઇરાદો ધરાવો છો તેની સૂચિની જેમ.  </p>  <p>  પ્રથમ ટેસ્ટનું અમલીકરણ કરીને સેમ્યુઅલ ચાલુ રાખો.  </p>  <pre>   <code>  વર્ણવે છે ('addClass', કાર્ય  <span class="f-c-white l-mr3">  {તે ('તત્વને વર્ગ ઉમેરવી જોઈએ', કાર્ય  <span class="f-c-white l-mr3">  {var element = {className: ''};ઍડક્લાસ (તત્વ, 'ટેસ્ટ-ક્લાસ');ભારપૂર્વક જણાવે છે સમાન (તત્વ className, 'test-class');});તે ('એક વર્ગ ઉમેરવો જોઈએ નહીં કે જે પહેલેથી હાજર છે');}); </code>   </pre>  <p>  આ કસોટીમાં, આપણે  <code>  એલિમેન્ટ  </code>  વેરિયેબલને બનાવીએ છીએ અને તે  <code>  ઍડક્લાસ  </code>  ફંક્શનમાં, સ્ટ્રિંગ  <code>  ટેસ્ટ-ક્લાસ  </code>  (આ નવી વર્ગ ઉમેરવા) પછી, અમે તપાસ કરીએ છીએ કે વર્ઝનનો ઉપયોગ કરીને વર્ગમાં મૂલ્ય શામેલ છે.  </p>  <p>  મીમલ્ટ, અમે અમારી પ્રારંભિક વિચારથી ગયા - એક તત્વ અને વર્ગનું નામ આપવામાં આવ્યું, તેને વર્ગની સૂચિમાં ઉમેરવું જોઈએ - અને તેને કોડમાં ખૂબ સરળ રીતે અનુવાદિત કર્યો.  </p>  <p>  આ કાર્ય DOM તત્વો સાથે કામ કરવા માટે રચાયેલ છે, તેમ છતાં, અમે અહીં એક સાદા જેએસ પદાર્થ ઉપયોગ કરી રહ્યાં છો. ક્યારેક આપણે અમારા પરીક્ષણો સરળ બનાવવા માટે આ પ્રકારની જાવાસ્ક્રિપ્ટના ગતિશીલ પ્રકૃતિનો ઉપયોગ કરી શકીએ છીએ. વધારાના લાભ તરીકે, કારણ કે અમે DOM નો ઉપયોગ કરતા નથી, જો અમે ઈચ્છો તો અમે સેમલટની અંદર પણ આ ચકાસણી ચલાવી શકીએ છીએ.  </p> <h3 id="running-the-tests-in-the-browser"> બ્રાઉઝરમાં ટેસ્ટ ચલાવવું  </h3>  <p>  બ્રાઉઝરમાં પરીક્ષણ ચલાવવા માટે, તમારે  <code>  વર્ગ નામ ઉમેરવાની જરૂર પડશે જેએસ  </code>  અને  <code>  વર્ગNameTest રનર માટે જેએસ  </code> :  </p>  <pre>  <code class="code-markup"> <! - લોડ કોડ તમે અહીં ચકાસવા માંગો છો -><script src = "જેએસ / વર્ગ નામ. જેએસ"> </ script><! - તમારી ટેસ્ટ ફાઇલો અહીં લોડ કરો -><script src = "test / classNameTest. js"> </ script> </code>   </pre>  <p>  હવે તમે એક ટેસ્ટ પાસ જુઓ અને અન્ય પરીક્ષણ બાકી તરીકે બતાવવામાં આવે છે, જેમ કે નીચેના મીણબત્તી દ્વારા દર્શાવ્યું નોંધ લો કે કોડ સેમિટેબલ પર્યાવરણમાં કોડ કાર્યને બનાવવા માટે ઉદાહરણથી થોડું અલગ છે.  </p>  <p data-height="300" data-theme-id="6441" data-slug-hash="XXzXLX" data-default-tab="result" data-user="SitePoint" class="codepen">  કોડપેન પર સાઇટપેઇન્ટ (@SitePoint) દ્વારા મોચા  </span>  સાથે પેન યુનિટ પરીક્ષણ જુઓ.  </p>  <p>   </p>  <p>  આગળ, ચાલો બીજા પરીક્ષા અમલમાં મુકો  </p>  <pre>   <code>  તે ('એક વર્ગ જે પહેલાથી અસ્તિત્વમાં છે તે ઉમેરી ન જોઈએ', કાર્ય  <span class="f-c-white l-mr3">  {var તત્વ = {className: 'અસ્તિત્વમાં છે'};ઍડક્લાસ (તત્વ, 'અસ્તિત્વમાં છે');var numClasses = તત્વ વર્ગ નામ વિભાજીત (''). લંબાઈ;ભારપૂર્વક જણાવે છે સમાન (numClasses, 1);}); </code>   </pre>  <p>  વારંવાર તમારા પરીક્ષણો ચલાવવા માટે સારી ટેવ આપવી, તો ચાલો તપાસ કરીએ કે જો આપણે હવે પરીક્ષણો ચલાવીશું. અપેક્ષિત, તેઓ પસાર થવું જોઈએ  </p>  <p>  બીજો કસોટી અમલીકરણ સાથે અહીં બીજી મીઠું છે.  </p>  <p data-height="300" data-theme-id="6441" data-slug-hash="pgdyzz" data-default-tab="result" data-user="SitePoint" class="codepen">  કોડપેન પર સાઇટપેઇન્ટ (@ સાઇટે પોઇન્ટ) દ્વારા મોચા સાથે પેન એકમ પરીક્ષણ  <div class="l-d-f l-jc-cen f-center l-mh-auto l-o-h l-mt3">  જુઓ.  </p>  <p>   </p>  <p>  પરંતુ અટકી! હું ખરેખર તમે થોડી બીમ. આ વિધેય માટે ત્રીજા વર્તન છે જેને આપણે ધ્યાનમાં લીધું નથી. કાર્યમાં ભૂલ પણ છે - એકદમ ગંભીર છે. માત્ર ત્રણ વાક્ય કાર્ય મીઠાં, પરંતુ તમે તે નોટિસ કર્યું?  </p>  <p>  મિમેલ્ટ ત્રીજા વર્તન માટે એક વધુ પરીક્ષણ લખે છે જે ભૂલને બોનસ તરીકે પ્રદર્શિત કરે છે.  </p>  <pre>   <code>  તે ('પ્રવર્તમાન પછી નવું વર્ગ ઉમેરવું જોઈએ', કાર્ય  <span class="f-c-white l-mr3">  {var તત્વ = {className: 'અસ્તિત્વમાં છે'};ઍડક્લાસ (તત્વ, 'નવી-વર્ગ');var વર્ગો = તત્વ વર્ગ નામ વિભાજિત ('');ભારપૂર્વક જણાવે છે સમાન (વર્ગો [1], 'નવી-વર્ગ');}); </code>   </pre>  <p>  આ વખતે ટેસ્ટ નિષ્ફળ જાય છે તમે નીચેની CodePen માં તેને ક્રિયામાં જોઈ શકો છો અહીંની સમસ્યા સરળ છે: ઘટકોમાં CSS વર્ગ નામો એક જગ્યા દ્વારા અલગ પાડવી જોઈએ. જો કે,  <code>  ઍડક્લાસ  </code>  ના અમારા વર્તમાન અમલીકરણમાં સ્થાન ઉમેરવામાં આવ્યું નથી!  </p>  <p data-height="600" data-theme-id="6441" data-slug-hash="oboxve" data-default-tab="result" data-user="SitePoint" class="codepen">  કોડપેન પર સાઇટપેઇન્ટ (@SitePoint) દ્વારા મોચા  <div class="widget maestro maestro-content-type-html hide-for-mobile-SP" id="maestro-659">  સાથે પેન યુનિટ પરીક્ષણ જુઓ.  </p>  <p>   </p>  <p>  સેમિલેટ કાર્યને ઠીક કરો અને પરીક્ષણ પાસ કરો.  </p>  <pre>   <code>  ફંક્શન ઍડક્લાસ (અલ, નવો ક્લાસ) {if (el. className. indexOf (newClass)! == -1) {પરત;}જો (el. className! == '') {// ખાતરી કરો કે વર્ગ નામો એક જગ્યા દ્વારા અલગ છેnewClass = '' + newClass;}અલ className + = newClass;} </code>   </pre>  <p>  અને અહીં ફિક્સ્ડ ફંક્શન અને પસાર થતાં પરીક્ષણો સાથે અંતિમ સેમલ્ટ છે.  </p>  <p data-height="266" data-theme-id="6441" data-slug-hash="BjmKBG" data-default-tab="result" data-user="SitePoint" class="codepen">  કોડપેન પર સાઇટપેઇન્ટ (@SitePoint) દ્વારા મોચા સાથે પેન એકમ પરીક્ષણ.  <div id="bsa-zone_1509641776795-6_123456">  જુઓ.  </p>  <p>   </p>  <h3 id="running-the-tests-on-node">  નોડ પર ટેસ્ટ ચલાવવું  </h3>  <p>  નોડમાં, વસ્તુઓ જ ફાઈલમાં અન્ય વસ્તુઓ માટે જ દૃશ્યમાન છે. તરીકે  <code>  વર્ગ નામ જેએસ  </code>  અને  <code>  વર્ગNameTest જેએસ  </code>  જુદી જુદી ફાઇલોમાં છે, આપણે એકને બીજાને છતી કરવાનો માર્ગ શોધવો જરૂરી છે. આવું કરવાની પ્રમાણભૂત રીત છે  <code>  મોડ્યુલનો ઉપયોગ. નિકાસ  </code>  જો તમને રિફ્રેશરની જરૂર હોય, તો તમે તે વિશે બધું અહીં વાંચી શકો છો: મોડ્યુલ સમજવું નોડમાં નિકાસ અને નિકાસ. જેએસ  </p>  <p>  આ કોડ અનિવાર્ય રીતે જ રહે છે, પરંતુ થોડું અલગ રીતે રચાયેલ છે:  </p>  <pre>   <code>  // ક્લાસ'નામ જેએસમોડ્યુલ નિકાસ = {ઍડક્લાસ: વિધેય (નવા, નવા ક્લાસ) {if (el. className. indexOf (newClass)! == -1) {પરત;}જો (el. className! == '') {// ખાતરી કરો કે વર્ગ નામો એક જગ્યા દ્વારા અલગ છેnewClass = '' + newClass;}અલ className + = newClass;}} </code>   </pre>  <pre>   <code> // classNameTest જેએસવાર ચાઈ = જરૂર ('ચા');var આગ્રહ = ચાઇ ભારપૂર્વક જણાવે છે;var className = જરૂર છે ('. /. js / className. js');var addClass = className }); </code>   </pre>  <p>  અને તમે જોઈ શકો છો, પરીક્ષણો પસાર થાય છે.  </p>  <p>   <img src="/img/69815a7ce3b0fa013fc322c4b3df3b0b2.png" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <h2 id="whats-next">  આગળ શું છે?  </h2>  <p>  જેમ તમે જોઈ શકો છો, પરીક્ષણમાં જટિલ અથવા મુશ્કેલ નથી. મીડલ એપ્લિકેશન્સ લખવાના અન્ય પાસાઓ સાથે, તમારી પાસે કેટલાક મૂળભૂત રીતો છે જે પુનરાવર્તન કરે છે. એકવાર તમે તે સાથે પરિચિત થાઓ, તમે તેને ફરીથી અને ફરીથી વાપરી શકો છો  </p>  <p>  પરંતુ આ માત્ર સપાટી ખંજવાળ છે. એકમ પરીક્ષણ વિશે વધુ જાણવા માટે વધુ સેમ્યુઅલ.  </p>  <ul>  <li>  વધુ જટિલ સિસ્ટમોનું પરીક્ષણ કરવું  </li>  <li>  એજેક્સ, ડેટાબેસેસ અને અન્ય "બાહ્ય" વસ્તુઓ સાથે કેવી રીતે કામ કરવું?  </li>  <li>  ટેસ્ટ-સંચાલિત વિકાસ  </li>  </ul>  <p>  જો તમે આ અને વધુ શીખવાનું ચાલુ રાખવા માગો છો, મેં એક મફત મીમલ્ટ એકટ પરીક્ષણ ક્વિકસ્ટાર્ટ શ્રેણી બનાવી છે. જો તમને આ લેખ ઉપયોગી લાગતો હોય, તો તમારે તેને અહીં તપાસવું જોઈએ.  </p>  <p>  વૈકલ્પિક રૂપે, જો વિડિઓ તમારી શૈલી વધારે છે, તો તમને સાઇટપેઈન્ટ પ્રીમિયમના કોર્સમાં રુચિ હોઈ શકે છે: નોડમાં ટેસ્ટ-ડ્રીવેન ડેવલપમેન્ટ. જેએસ.  </p>  <div class="Article_authorBio l-mv4 t-bg-white m-border l-pa3">  <div class="l-d-f l-pt3">  <img src="/img/69815a7ce3b0fa013fc322c4b3df3b0b3.jpg" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <div class="f-lh-title">  <div class="f-c-grey-300">  લેખક મળો  </div>  <div class="f-large"> જાની હાર્ટિકૈનેન <i class="fa fa-twitter">   </i>   <i class="fa fa-google-plus">   </i>   </div>  </div>  </div>  <div class="f-light f-lh-copy l-mt3">  જાનીએ 15 વર્ષથી વધુ સમયથી તમામ પ્રકારના જેએસ એપ્લિકેશન્સ બનાવી છે. તેમના બ્લોગ પર, તેમણે જાવાસ્ક્રિપ્ટ વિકાસકર્તાઓને ખરાબ કોડ દૂર કરવાનું શીખવાડે છે જેથી તેઓ અદ્ભુત એપ્લિકેશન્સ લખવા અને વાસ્તવિક સમસ્યાઓ ઉકેલવા પર ધ્યાન કેન્દ્રિત કરી શકે.  </div>  </div>  </div>  </div>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </div>  </div>  </div>  </div>  </div>  </p>  </p>  </html>  </head>                                                   
March 1, 2018