Gruntle Software & Testing

દ્વારા Stewart Tristianપોસ્ટ કર્યું પોસ્ટ કર્યું માર્ગદર્શિકાઓ

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

API એ એક ટૂંકું નામ છે જે એપ્લિકેશન પ્રોગ્રામિંગ ઈન્ટરફેસ માટે વપરાય છે. સરળ શબ્દોમાં, અમે તેને સોફ્ટવેર મધ્યસ્થી તરીકે વ્યાખ્યાયિત કરી શકીએ છીએ જે એપ્લિકેશનો વચ્ચે સંચારની મંજૂરી આપે છે.

અમને API પરીક્ષણની જરૂર છે કારણ કે:

  • પરિણામો ઝડપથી પ્રકાશિત થાય છે, તેથી API બરાબર કામ કરી રહ્યું છે કે કેમ તે જોવા માટે હવે રાહ જોવાની જરૂર નથી.
  • ઝડપી પ્રતિસાદ સાથે, આ API ની જમાવટ પણ ઝડપી બને છે, તેથી ઝડપી ટર્નઅરાઉન્ડ સમય માટે પરવાનગી આપે છે.
  • પ્રારંભિક નિષ્ફળતા શોધ, એપનું UI બનાવવામાં આવે તે પહેલાં જ, અમને જોખમો ઘટાડવા અને ખામીઓને સુધારવાની મંજૂરી આપો.
  • ટૂંકા સમયગાળામાં મોટા પાયે ડિલિવરી શક્ય છે.

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

કરાટે ફ્રેમવર્ક તેના અગાઉના સોફ્ટવેર ટૂલ્સના આ મુદ્દાને સુંદર રીતે હલ કરે છે.

કરાટે ફ્રેમવર્ક શું છે

કરાટે? ચાલો કરાટેની વાત કરીએ. શું તે જાપાનનું છે? તમે શુ વિચારો છો, તમને શુ લાગે છે? તે મહાન બ્રુસ હોઈ શકે છેઆ કરાટે બેઝિક ટેસ્ટ સ્ક્રિપ્ટ.

દૃશ્ય:

અમે આ URL સાથે APIનું પરીક્ષણ કરીશું.

પાથ: api/users/2

પદ્ધતિ: GET

અને અમારે માન્ય કરવાની જરૂર છે , શું વિનંતી સક્સેસ કોડ ( 200) અથવા નહીં.

સાદા શબ્દોમાં, અમે ફક્ત એક નમૂના APIનું પરીક્ષણ કરવા જઈ રહ્યા છીએ કે તે સફળતાપૂર્વક એક્ઝિક્યુટ થઈ રહ્યું છે કે નહીં.

નોંધ: અમે એક નમૂના API લઈ રહ્યા છીએ જે પરીક્ષણ માટે ઉપલબ્ધ છે. તમે કોઈપણ PATH પસંદ કરી શકો છો અથવા તમારા API નો સંદર્ભ લઈ શકો છો.

સ્રોત માટે અહીં ક્લિક કરો.

#5) હવે અમારું આગલું પગલું બનાવવાનું હશે. .feature ફાઈલ.

પરિચય વિભાગમાં ચર્ચા કર્યા મુજબ, .feature file એ એવી મિલકત છે જે કાકડી પાસેથી વારસામાં મળી છે. આ ફાઇલમાં, અમે પરીક્ષણ દૃશ્યો લખીશું જે API પરીક્ષણ કરવા માટે ચલાવવાની જરૂર છે.

  • તમારા પ્રોજેક્ટમાં ફોલ્ડર src/test/java પર જાઓ.

  • તેના પર રાઇટ ક્લિક કરો અને નવી ફાઇલ બનાવો - userDetails.feature. પછી ફિનિશ બટન પર ક્લિક કરો.

હવે તમે ફોલ્ડર src/test/java હેઠળ નીચેની ફાઇલ જોશો. 3>

લીલા રંગનું ચિહ્ન કાકડીમાં .ફીચર fi le જેવું લાગે છે જે અમે હમણાં જ બનાવ્યું છે.

  • એકવાર ફાઇલ બની ગયા પછી, હવે અમે અમારા પરીક્ષણ દૃશ્યો લખીશું જેની ચર્ચા નીચેના વિભાગમાં કરવામાં આવશે.

#6) કારણ કે અમારી પાસે દૃશ્ય છે અનેખાલી . સુવિધા ફાઇલ તૈયાર છે, હવે ચાલો અમારી પ્રથમ સ્ક્રિપ્ટ સાથે પ્રારંભ કરીએ. ચાલો કોડિંગ શરૂ કરીએ

userDetails.feature ફાઇલ હેઠળ કોડની નીચેની લાઇન લખો જે આપણે સ્ટેપ # 5 માં બનાવી છે: 

 Feature: fetching User Details Scenario: testing the get call for User Details Given url '//reqres.in/api/users/2' When method GET Then status 200

ચાલો સમજવાનો પ્રયાસ કરીએ ઉપરોક્ત ફાઈલમાં લખેલા ઘટકો:

  • સુવિધા: કીવર્ડ એ સુવિધાનું નામ સમજાવે છે જેનું અમે પરીક્ષણ કરી રહ્યા છીએ.
  • પૃષ્ઠભૂમિ: આ એક વૈકલ્પિક વિભાગ છે જેને પૂર્વ-જરૂરી વિભાગ તરીકે ગણવામાં આવે છે. API ને ચકાસવા માટે શું જરૂરી છે તે વ્યાખ્યાયિત કરવા માટે તેનો ઉપયોગ કરી શકાય છે. તેમાં HEADER, URL & PARAM વિકલ્પો.
  • દૃશ્ય: તમે જોશો તે દરેક ફીચર ફાઇલમાં ઓછામાં ઓછી એક સુવિધા હશે (જોકે તે બહુવિધ પરિદ્રશ્ય આપી શકે છે) . તે ટેસ્ટ કેસનું વર્ણન છે.
  • આપવામાં આવ્યું છે: તે એક પગલું છે જે કોઈપણ અન્ય ટેસ્ટ સ્ટેપ કરવામાં આવે તે પહેલાં એક્ઝિક્યુટ કરવાની જરૂર છે. તે ફરજિયાત કરવાની ક્રિયા છે.
  • ક્યારે: તે તે શરતનો ઉલ્લેખ કરે છે કે જે આગળનું પરીક્ષણ પગલું કરવા માટે મળવું જોઈએ.
  • પછી: તે અમને જણાવે છે કે જ્યારે સંતુષ્ટ થાય છે ત્યારે શું થવું જોઈએ.

નોંધ: ઉપર જણાવેલ બધા કીવર્ડ્સ છે ગેર્કિન્સ ભાષામાંથી. કાકડીનો ઉપયોગ કરીને ટેસ્ટ સ્ક્રિપ્ટો લખવાની આ પ્રમાણભૂત રીત છે.

અને ફીચર ફાઇલમાં ઉપયોગમાં લેવાતા કેટલાક વધુ શબ્દો છે:

  • 200: તે સ્થિતિ/પ્રતિસાદ કોડ છે જે આપણે છીએઅપેક્ષા (સ્ટેટસ કોડની યાદી માટે અહીં ક્લિક કરો)
  • મેળવો: તે POST, PUT વગેરે જેવી API પદ્ધતિ છે.

અમે આ સ્પષ્ટતાની આશા રાખીએ છીએ તમારા માટે સમજવું સરળ હતું. હવે તમે ઉપરોક્ત ફાઇલમાં બરાબર શું લખેલું છે તેની સાથે સંબંધિત કરી શકશો.

હવે આપણે TestRunner.java ફાઇલ બનાવવાની જરૂર છે

ઉપર સમજાવ્યા પ્રમાણે વિભાગમાં, કાકડીને એક રનર ફાઇલની જરૂર છે જે .સુવિધા ફાઇલને એક્ઝિક્યુટ કરવા માટે જરૂરી છે જેમાં પરીક્ષણના દૃશ્યો છે.

  • ફોલ્ડર src/test/javaપર જાઓ 2> તમારા પ્રોજેક્ટમાં

  • તેના પર રાઇટ ક્લિક કરો અને નવી Java ફાઇલ બનાવો: TestRunner.java
  • એકવાર ફાઈલ બની જાય પછી, તેની નીચે કોડની નીચેની લીટીઓ મૂકો: 
 import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { }
  • ટેસ્ટ રનર એ ફાઈલ છે જે હવે કરવા માટે ચલાવવામાં આવશે. ઇચ્છિત દૃશ્ય કે જે પગલું #5 હેઠળ લખવામાં આવ્યું છે.

#7) હવે આપણે બંને ફાઇલો સાથે તૈયાર છીએ TestRunner.Java અને userDeatils.feature. અમારા માટે માત્ર એક જ કાર્ય બાકી છે ચલાવો સ્ક્રીપ્ટ.

  • TestRunner.java ફાઇલ પર જાઓ અને નીચેની ઇમેજમાં બતાવ્યા પ્રમાણે ફાઇલ પર જમણું-ક્લિક કરો.

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

  • આખરે, અમે કહી શકીએ છીએ.કે અમે કરાટે ફ્રેમવર્કનો ઉપયોગ કરીને અમારી પ્રથમ મૂળભૂત ટેસ્ટ સ્ક્રિપ્ટ સફળતાપૂર્વક બનાવી છે.

#8) છેલ્લે, કરાટે ફ્રેમવર્ક એક્ઝેક્યુશન માટે HTML રિપોર્ટ પ્રેઝન્ટેશન પણ આપે છે જે કરવામાં આવ્યું છે.

  • ટાર્ગેટ ફોલ્ડર પર જાઓ -> surefire-reports-> અહીં તમે તમારો HTML રિપોર્ટ જોશો જે તમે ખોલી શકો છો.

** અમે તમને Chrome નો ઉપયોગ કરીને તેને ખોલવાનું પણ સૂચવીશું. બહેતર દેખાવ અને અનુભૂતિ માટે બ્રાઉઝર.

  • નિમ્નલિખિત HTML રિપોર્ટ તમને પરિદ્રશ્યો અને amp; ટેસ્ટ કે જે ઉલ્લેખિત દૃશ્ય માટે ચલાવવામાં આવ્યું છે:

નિષ્કર્ષ

આ ટ્યુટોરીયલમાં, અમે API પરીક્ષણ, વિવિધ પરીક્ષણની ચર્ચા કરી છે. બજારમાં ઉપલબ્ધ સાધનો, અને કરાટે ફ્રેમવર્ક તેના સમકક્ષોની સરખામણીમાં કેવી રીતે વધુ સારો વિકલ્પ છે.

અમે અમારી પ્રથમ મૂળભૂત કસોટી સ્ક્રિપ્ટ બનાવવા માટે પગલું-દર-પગલાંનો અભિગમ અપનાવ્યો છે. અમે .feature ફાઇલ બનાવવા માટે મૂળભૂત Eclipse IDE માં મેવન પ્રોજેક્ટ બનાવવાની સાથે શરૂઆત કરી છે, જેમાં તમામ ટેસ્ટીંગ સિનેરીયો અને .feature ફાઇલમાં દર્શાવેલ ટેસ્ટ કેસને એક્ઝિક્યુટ કરવા માટે રનર ફાઇલ છે.

બહુવિધ પગલાઓના અંતે, અમે પરીક્ષણ પરિણામોનો અમલ અહેવાલ જોઈ શકીએ છીએ.

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

આગળ>>

લીએ તેના ફ્રી ટાઇમમાં આનો વિકાસ કર્યો હતો.

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

કરાટે ફ્રેમવર્ક પ્રોગ્રામ લખવાની કાકડી શૈલીને અનુસરે છે જે BDD અભિગમને અનુસરે છે. બિન-પ્રોગ્રામર્સ દ્વારા સિન્ટેક્સ સમજવામાં સરળ છે. અને આ ફ્રેમવર્ક એકમાત્ર API પરીક્ષણ સાધન છે જેણે API ઓટોમેશન અને પ્રદર્શન પરીક્ષણને એક એકલ સાધનમાં જોડ્યું છે.

તે વપરાશકર્તાઓને સમાંતરમાં પરીક્ષણ કેસ ચલાવવાની અને JSON & XML તપાસે છે.

આ માહિતી સાથે, કરાટે ટૂલને વધુ વિગતવાર સમજવા માટે અમુક મુખ્ય મુદ્દાઓ કાઢી શકાય છે:

  • કરાટે એ BDD પરીક્ષણ માળખું છે. TDD.
  • તે બિન-પ્રોગ્રામર્સ માટે સરળ બનાવવા માટે રચાયેલ છે. આ સુવિધા ગેમ-ચેન્જર છે કારણ કે તે ઘણા લોકોને તેમની તકનીકી પૃષ્ઠભૂમિ અથવા ક્ષમતાને ધ્યાનમાં લીધા વિના વધુ ઉપયોગ અને ઍક્સેસની મંજૂરી આપે છે.
  • તે પરીક્ષણ લખવા માટે કાકડી ફીચર ફાઇલ અને ગેર્કિન્સ ભાષાનો ઉપયોગ કરે છે જે સમજવામાં ખૂબ જ સરળ છે.

આ તમામ સુવિધાઓ તેને આજે ઉપલબ્ધ સૌથી અનુકૂળ ઓટોમેશન ટૂલ્સમાંથી એક બનાવે છે.

કરાટે ફ્રેમવર્કનો ઇતિહાસ

'દ્વારા બનાવાયેલ 1>પીટર થોમસ' 2017 માં, આ સોફ્ટવેરનું લક્ષ્ય પરીક્ષણ કરવાનું છેદરેક માટે સરળતાથી ઉપલબ્ધ કાર્યક્ષમતા. તે જાવામાં લખવામાં આવ્યું હતું અને મોટાભાગના લોકોએ તેની ફાઇલો પણ તે જ ભાષામાં હોવાની અપેક્ષા રાખી હતી, જો કે, સદભાગ્યે, એવું નથી.

તેના બદલે, તે ગેર્કિન્સ ફાઇલોનો ઉપયોગ કરે છે, જે તેની સાથે તેના સંબંધનું પરિણામ છે. કાકડી ફ્રેમવર્ક. ઓટોમેશન સોફ્ટવેર એ કાકડીનું વિસ્તરણ છે, તેથી તેની કામગીરીમાં ગેરકિન્સ ફાઇલનો ઉપયોગ વારસામાં મળે છે. બંને વચ્ચેનો મોટો તફાવત એ છે કે કરાટે પરીક્ષણ કરતી વખતે જાવાનો કોઈ ઉપયોગ કરતું નથી, પરંતુ કાકડી કરે છે.

આ જ કારણ છે કે તે બિન-પ્રોગ્રામર્સને સંતોષે છે કારણ કે ગેર્કિન્સ સિન્ટેક્સ સુપર વાંચી શકાય તેવું અને વ્યાપક છે. આ જ કારણ છે કે ઓટોમેટેડ API ટેસ્ટિંગની દુનિયામાં પ્રવેશ કરવા માટે કરાટે સૌથી યોગ્ય અને ભલામણ કરવામાં આવે છે.

કરાટે ટેસ્ટિંગ ફ્રેમવર્કની કેટલીક વિશેષતાઓ નીચે મુજબ છે:

4
  • ઘેરકિન્સ ભાષાને સમજવામાં સરળતાનો ઉપયોગ કરે છે.
  • તેને જાવા જેવા ટેકનિકલ પ્રોગ્રામિંગ જ્ઞાનની જરૂર નથી.
  • તે લોકપ્રિય કાકડી ધોરણો પર આધારિત છે.
  • એક ફ્રેમવર્ક બનાવવા માટે સરળ છે.
  • સમાંતર પરીક્ષણ એ મુખ્ય કાર્યક્ષમતા છે જે કરાટે દ્વારા જ પ્રદાન કરવામાં આવે છે, તેથી આપણે મેવેન, ગ્રેડલ , વગેરે પર આધાર રાખવાની જરૂર નથી.
  • ટેસ્ટને ડીબગ કરવા માટે UI.
  • બીજી ફાઇલમાંથી ફીચર ફાઇલને કૉલ કરવું.
  • ડેટા ડ્રાઇવર ટેસ્ટિંગ માટે સપોર્ટ પૂરો પાડે છે જે ઇન-હાઉસ બનાવવામાં આવે છે, તેથી બાહ્ય ફ્રેમવર્ક પર આધાર રાખવાની જરૂર નથી.
  • બિલ્ટ-ઇન નેટિવ રેસ્ટઅહેવાલો. ઉપરાંત, તેને વધુ સારા UI રિપોર્ટ્સ અને વધુ સ્પષ્ટતા માટે કાકડી સાથે સંકલિત કરી શકાય છે.
  • વિવિધ પરીક્ષણ વાતાવરણમાં (QA, સ્ટેજ, પ્રોડ, પ્રી-પ્રોડ) રૂપરેખાંકન સ્વિચ કરવા માટે ઇન-હાઉસ સપોર્ટ પૂરો પાડે છે.
  • CI/CD એકીકરણ માટે સીમલેસ સપોર્ટ જે ઉપયોગી થઈ શકે છે.
  • વિવિધ HTTP કૉલ્સને હેન્ડલ કરવામાં સક્ષમ:
    • વેબ સોકેટ સપોર્ટ
    • SOAP વિનંતી
    • HTTP
    • બ્રાઉઝર કૂકી હેન્ડલિંગ
    • HTTPS
    • HTML-ફોર્મ ડેટા
    • XML વિનંતી

    • કરાટે વિ રેસ્ટ-એશ્યોર્ડની સરખામણી

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

    કરાટે ફ્રેમવર્ક : એક કાકડી/ગેરકિન્સ આધારિત સાધન, જેનો ઉપયોગ SOAP & REST સેવાઓ.

    નીચેનું કોષ્ટક રેસ્ટ-એશ્યોર્ડ અને amp; કરાટે ફ્રેમવર્ક:

    20
    S.No આધાર કરાટે ફ્રેમવર્ક રેસ્ટ-એશ્યોર્ડ
    1 ભાષા તે કાકડી અને ગેર્કીન્સના સંયોજનનો ઉપયોગ કરે છે તે જાવા ભાષાનો ઉપયોગ કરે છે
    2 કોડનું કદ સામાન્ય રીતે, કોડ ઓછો છે, કારણ કે તે કાકડી જેવી રચનાને અનુસરે છે કોડની લાઇન વધુ છે કારણ કે તેમાંજાવા ભાષાનો ઉપયોગ
    3 તકનીકી જ્ઞાન જરૂરી બિન-પ્રોગ્રામર સરળતાથી લખી શકે છે ગેર્કિન્સ કોડ જાવા કોડ લખવા માટે ટેકનિકલ જ્ઞાન જરૂરી છે
    4 ડેટા-ડ્રિવન ટેસ્ટિંગ તેને ટેકો આપવા માટે TestNG અથવા સમકક્ષનો ઉપયોગ કરવાની જરૂર છે ડેટા પરીક્ષણને સમર્થન આપવા માટે ઇન-હાઉસ ટૅગ્સનો ઉપયોગ કરી શકાય છે
    5 શું તે SOAP કૉલ સપોર્ટ પ્રદાન કરે છે હા, તે પ્રદાન કરે છે તે માત્ર REST વિનંતી સાથે સંબંધિત છે
    6 સમાંતર પરીક્ષણ હા, સમાંતર રિપોર્ટ જનરેશન સાથે સમાંતર પરીક્ષણ સરળતાથી સમર્થિત છે પણ મોટા પ્રમાણમાં નથી. લોકોએ આ કરવાનો પ્રયાસ કર્યો હોવા છતાં, નિષ્ફળતા દર સફળતા દર કરતાં વધુ છે
    7 રિપોર્ટિંગ 23 તે ઇન-હાઉસ રિપોર્ટિંગ પ્રદાન કરે છે, તેથી બાહ્ય પ્લગિન્સ પર નિર્ભર રહેવાની જરૂર નથી. અમે તેને વધુ સારા UI માટે કાકડી રિપોર્ટિંગ પ્લગઇન સાથે પણ સંકલિત કરી શકીએ છીએ. જ્યુનિટ, ટેસ્ટએનજી જેવા બાહ્ય પ્લગઇન્સ પર નિર્ભર રહેવાની જરૂર છે
    8 બાહ્ય ડેટા માટે CSV સપોર્ટ હા, કરાટેથી 0.9.0 ના, જાવા કોડ અથવા લાઇબ્રેરીનો ઉપયોગ કરવો પડશે
    9 વેબ UI ઓટોમેશન હા, કરાટેથી 0.9.5 વેબ-UI ઓટોમેશન શક્ય છે ના, તે સમર્થિત નથી
    10 સેમ્પલ મેળવો Given param val1 = ‘name1’

    And param val2 = ‘name2’

    And path ‘somelocation’

    When method get

    Then match response contains ‘OKAY’

    		given().

    param("val1", "name1").

    param("val2", "name2").

    when().

    get("/some\location").

    then().

    body(containsString("OKAY"));

    તેથી, દ્વારા દર્શાવ્યા મુજબ ઉપરોક્ત તફાવતો, તે કહેવું સલામત છે કે કરાટે એ સૌથી સરળ વસ્તુઓ પૈકીની એક છે જે કોઈપણ કરી શકે છે.

    કરાટે ફ્રેમવર્ક સાથે કામ કરવા માટે જરૂરી સાધનો

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

    #1) Eclipse

    Eclipse એ એક સંકલિત વિકાસ પર્યાવરણ છે જેનો ઉપયોગ કરવામાં આવે છે. કમ્પ્યુટર પ્રોગ્રામિંગના ક્ષેત્રમાં. તે મોટે ભાગે જાવા પ્રોગ્રામિંગ માટે વપરાય છે. અગાઉ ઉલ્લેખ કર્યો છે તેમ, કરાટે જાવામાં લખાયેલું છે, તેથી તે વધુ અર્થપૂર્ણ બને છે કે શા માટે Eclipse એ API ટેસ્ટ સોફ્ટવેર માટે ગો-ટૂ IDE છે. બીજું કારણ એ છે કે તે એક ઓપન-સોર્સ ટૂલ છે, અને આ ટૂલ પસંદ કરવા માટે આ એક ખૂબ જ મજબૂત કારણ છે.

    નોંધ: અમે ઇન્ટેલિજે, વિઝ્યુઅલ સ્ટુડિયો અને અન્ય વિવિધ બજારમાં ઉપલબ્ધ સંપાદકો.

    #2) માવેન

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

    મેવેનમાં કામ કરતી વખતે, મેવન ડિપેન્ડન્સીનો ઉપયોગ કરો જે તમને કરાટે ફ્રેમવર્કને સપોર્ટ કરવામાં મદદ કરશે.

    નીચે આપેલ pom.xml માં Maven સાથે નિર્ભરતાઓનો ઉપયોગ કરવામાં આવશે. 

       com.intuit.karate karate-apache 0.9.5 test   com.intuit.karate karate-junit4 0.9.5 test

    નોંધ: નવીનતમ સંસ્કરણો કદાચમેવન રિપોઝીટરીમાં ઉપલબ્ધ છે.

    #3) ગ્રેડલ

    ગ્રેડલ એ મેવેનનો વિકલ્પ છે અને તેનો સમાન ક્ષમતામાં ઉપયોગ કરી શકાય છે. તેમની સમાનતા અને તફાવતો છે પરંતુ અમારા કરાટે કોડ્સ માટે પર્યાવરણ સેટ કરવા માટે સમાન રીતે ઉપયોગ કરી શકાય છે.

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

    testCompile 'com.intuit.karate:karate-junit4:0.6.0' testCompile 'com.intuit.karate:karate-apache:0.6.0'

    નોંધ: તમે કાં તો MAVEN અથવા GRADLE નો ઉપયોગ કરી શકો છો.

    0 #4) તમારી સિસ્ટમમાં જાવા એન્વાયર્નમેન્ટ સેટઅપ

    કરાટે ફ્રેમવર્ક સ્ક્રિપ્ટ્સ સાથે પ્રારંભ કરવા માટે JDK અને JRE પર્યાવરણ સેટઅપ કરવાની જરૂર છે.

    કરાટે ટેસ્ટ સ્ક્રિપ્ટનું માળખું

    કરાટે ટેસ્ટ સ્ક્રિપ્ટ “.feature” એક્સ્ટેંશનના કબજા માટે જાણીતી છે. આ મિલકત કાકડી પાસેથી વારસામાં મળી છે. જાવા સંમેલનમાં ફાઇલોના સંગઠનને પણ સમાન રીતે પરવાનગી છે. તમે તમારી ફાઇલોને Java પેકેજ સંમેલનો અનુસાર ગોઠવવા માટે મુક્ત છો.

    જો કે, Maven માર્ગદર્શિકા સૂચના આપે છે કે બિન-જાવા ફાઇલોનો સંગ્રહ અલગથી કરવામાં આવે. તે src/test/resources બંધારણમાં કરવામાં આવે છે. અને Java ફાઇલોને src/main/java હેઠળ રાખવામાં આવે છે.

    પરંતુ કરાટે ફ્રેમવર્કના નિર્માતાઓ મુજબ, તેઓ દૃઢપણે માને છે કે અમે જાવા અને નોન-જાવા ફાઇલોને બાજુમાં રાખીએ છીએ. બાજુ તેમના જણાવ્યા મુજબ, તે માટે જોવાનું ખૂબ સરળ છે*.java અને *.feature ફાઈલો જ્યારે તેઓને એકસાથે રાખવામાં આવે છે, પ્રમાણભૂત મેવેન સ્ટ્રક્ચરને અનુસરવાને બદલે.

    આ તમારા pom.xml ને નીચે પ્રમાણે ટ્વીક કરીને સરળતાથી કરી શકાય છે (માવેન માટે): 

        src/test/java  **/*.java     ...

    નીચે કરાટે ફ્રેમવર્કની સામાન્ય રચનાની રૂપરેખા છે:

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

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

    "રનર" વર્ગ મોટાભાગે TestRunner.java. નામનો હોય છે.

    પછી TestRunner.java ફાઈલ આનું સ્વરૂપ લેશે: 

     import com.intuit.karate.junit4.Karate; import org.junit.runner.RunWith; @RunWith(Karate.class) public class TestRunner { }

    અને .feature ફાઈલ વિશે વાત કરીએ તો, તેમાં તમામ પરીક્ષણો શામેલ છે API અપેક્ષિત આવશ્યકતાઓ મુજબ કાર્ય કરી રહ્યું છે તેની ખાતરી કરવા માટે પરીક્ષણ કરવાની જરૂર હોય તેવા દૃશ્યો.

    સામાન્ય *. લક્ષણ ફાઇલ નીચે બતાવ્યા પ્રમાણે કંઈક દેખાય છે: 

     Feature: fetching User Details Scenario: testing the get call for User Details Given url '//reqres.in/api/users/2' When method GET Then status 200

    પ્રથમ બેઝિક કરાટે ટેસ્ટ સ્ક્રિપ્ટ બનાવવી

    આ વિભાગ તમને તમારી પ્રથમ ટેસ્ટ સ્ક્રિપ્ટ બનાવવાની શરૂઆત કરવામાં મદદ કરશે, જે તમારા માટે API ને કરાટે ફ્રેમવર્કના રૂપમાં કન્વર્ટ કરવામાં મદદરૂપ થશે.

    આપણે મૂળભૂત કરાટે ટેસ્ટ સ્ક્રિપ્ટો લખીએ તે પહેલાં,કૃપા કરીને તમારા મશીન પર નીચેની આવશ્યકતાઓને ઇન્સ્ટોલ કરો:

    • Eclipse IDE
    • Maven. યોગ્ય માવેન પાથ સેટ કરો.
    • JDK & જેઆરઈ. યોગ્ય પાથ સેટ કરો.

    ચાલો સ્ટેપ-બાય-સ્ટેપ અભિગમ જોઈએ:

    #1) એક બનાવો નવો MAVEN પ્રોજેક્ટ Eclipse Editor માં

    • Open Eclipse
    • ફાઈલ પર ક્લિક કરો. નવો પ્રોજેક્ટ પસંદ કરો.

    • માવેન પ્રોજેક્ટ પસંદ કરો

    • પસંદ કરો વર્કસ્પેસ સ્થાન.
    • આર્કિટાઇપ પસંદ કરો (સામાન્ય રીતે અમે સરળ મેવેન પ્રોજેક્ટ્સ માટે “ મેવેન-આર્કિટાઇપ-ક્વિકસ્ટાર્ટ 1.1 ” પસંદ કરીએ છીએ).
    • પૂરા કરો. જૂથ ID & આર્ટિફેક્ટ ID (અમે અમારા ઉદાહરણમાં નીચેના મૂલ્યોનો ઉપયોગ કર્યો છે).
      • ગ્રુપ ID : કરાટે
      • આર્ટિફેક્ટ ID: KarateTestScriptsSample
    • પૂર્ણ કરવા માટે Finish પર ક્લિક કરો સેટઅપ.

    #2) એકવાર બની ગયા પછી, હવે તમે પ્રોજેક્ટ એક્સપ્લોરર વિન્ડોમાં નીચેનું માળખું જોઈ શકશો.

    #3) તમારી બધી નિર્ભરતાઓ શામેલ કરો.

    અમારું પહેલું પગલું, સેટઅપ પછી અમે તે તમામ નિર્ભરતાઓને સમાવીશું જે જરૂરી હશે. અમલ માટે. અમે તમામ ટેગ POM.xml હેઠળ રાખીશું (ધારી લઈએ કે તમે POM.xml વપરાશ વિશે પહેલાથી જ વાકેફ છો).

    • POM.xml ખોલો અને નિર્ભરતા ટેગ હેઠળ નીચેના કોડની નકલ કરો અને સાચવો. ફાઈલ. 
      com.intuit.karate karate-apache 0.9.5 test   com.intuit.karate karate-junit4 0.9.5 test

    સ્રોત માટે અહીં ક્લિક કરો.

    #4) ચાલો દૃશ્ય પર વિચાર કરીએ, આપણે શું પરીક્ષણ કરવા જઈ રહ્યા છીએ

    ઉપર સ્ક્રોલ કરો