• എന്താണ് കരാട്ടെ ഫ്രെയിംവർക്ക്
• ഉപസംഹാരം
  • കരാട്ടെ ഫ്രെയിംവർക്കിന്റെ ചരിത്രം
• കരാട്ടെ Vs Rest-Assured താരതമ്യം ചെയ്യുന്നു
  • കരാട്ടെ ഫ്രെയിംവർക്കിനൊപ്പം പ്രവർത്തിക്കാൻ ആവശ്യമായ ഉപകരണങ്ങൾ
  • കരാട്ടെ ടെസ്റ്റ് സ്ക്രിപ്റ്റിന്റെ ഘടന

കരാട്ടെ ഫ്രെയിംവർക്ക് ഉപയോഗിച്ചുള്ള API ടെസ്റ്റിംഗിന്റെ ആമുഖമാണ് ഈ ട്യൂട്ടോറിയൽ. കരാട്ടെ ടെസ്റ്റ് സ്‌ക്രിപ്റ്റിന്റെ ഘടനയെക്കുറിച്ചും ആദ്യ ടെസ്റ്റ് സ്‌ക്രിപ്റ്റ് നിർമ്മിക്കുന്നതിനുള്ള ഘട്ടങ്ങളെക്കുറിച്ചും അറിയുക:

API എന്നത് ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇന്റർഫേസ് എന്നതിന്റെ ചുരുക്കെഴുത്താണ്. ലളിതമായി പറഞ്ഞാൽ, ആപ്ലിക്കേഷനുകൾക്കിടയിൽ ആശയവിനിമയം അനുവദിക്കുന്ന ഒരു സോഫ്‌റ്റ്‌വെയർ ഇടനിലക്കാരനായി ഞങ്ങൾക്ക് ഇതിനെ നിർവചിക്കാം.

ഞങ്ങൾക്ക് API പരിശോധന ആവശ്യമാണ് കാരണം:

• ഫലങ്ങൾ വേഗത്തിൽ പ്രസിദ്ധീകരിക്കുന്നു, അതിനാൽ API നന്നായി പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് കാണാൻ ഇനി കാത്തിരിക്കേണ്ടതില്ല.
• വേഗത്തിലുള്ള പ്രതികരണത്തോടൊപ്പം, ഈ API-കളുടെ വിന്യാസവും വേഗത്തിലാകുന്നു, അതിനാൽ വേഗത്തിലുള്ള ടേൺഅറൗണ്ട് സമയം അനുവദിക്കുന്നു.
• നേരത്തേ പരാജയം കണ്ടെത്തൽ, ആപ്പിന്റെ UI സൃഷ്‌ടിക്കുന്നതിന് മുമ്പുതന്നെ, അപകടസാധ്യതകൾ ലഘൂകരിക്കാനും തെറ്റുകൾ തിരുത്താനും ഞങ്ങളെ അനുവദിക്കുക.
• ചെറിയ കാലയളവിൽ വലിയ തോതിലുള്ള ഡെലിവറി സാധ്യമാണ്.

API ടെസ്റ്റിംഗിൽ പ്രവർത്തിക്കാൻ, പോസ്റ്റ്മാൻ, മോച്ച, ചായ് എന്നിങ്ങനെ വിവിധ ടൂളുകൾ ഞങ്ങൾക്ക് വിപണിയിൽ ലഭ്യമാണ്. ഇവ നല്ല ഫലങ്ങളും API-കൾ പരീക്ഷിക്കുന്നതിനുള്ള ഫലപ്രദമായ ഉപയോഗവും പ്രകടമാക്കി, എന്നിരുന്നാലും, ഇവ വളരെയധികം കോഡ് സ്വാധീനം ചെലുത്തുന്നു. ഇവ ഉപയോഗിക്കാൻ കഴിയണമെങ്കിൽ, ഒരാൾ സാങ്കേതികമായി മികച്ചതും പ്രോഗ്രാമിംഗ് ഭാഷകളുമായി പരിചിതനുമായിരിക്കണം.

കരാട്ടെ ഫ്രെയിംവർക്ക് അതിന്റെ മുമ്പത്തെ സോഫ്‌റ്റ്‌വെയർ ടൂളുകളുടെ ഈ പ്രശ്‌നം മനോഹരമായി പരിഹരിക്കുന്നു.

എന്താണ് കരാട്ടെ ഫ്രെയിംവർക്ക്

കരാട്ടെ? നമുക്ക് കരാട്ടെ സംസാരിക്കാം. ജപ്പാനിൽ നിന്നുള്ളതാണോ? നീ എന്ത് ചിന്തിക്കുന്നു? അതായിരിക്കാം മഹാനായ ബ്രൂസ്ഈ കരാട്ടെ അടിസ്ഥാന ടെസ്റ്റ് സ്ക്രിപ്റ്റ്.

സാഹചര്യം:

ഞങ്ങൾ ഈ URL ഉപയോഗിച്ച് ഒരു API പരീക്ഷിക്കും.

പാത്ത്: api/users/2

രീതി: GET

കൂടാതെ, അഭ്യർത്ഥന ഒരു വിജയ കോഡ് നൽകുന്നുണ്ടോ എന്ന് ഞങ്ങൾ സാധൂകരിക്കേണ്ടതുണ്ട് ( 200) അല്ലെങ്കിൽ ഇല്ല.

ലളിതമായി പറഞ്ഞാൽ, ഞങ്ങൾ ഒരു സാമ്പിൾ API വിജയകരമായി നടപ്പിലാക്കുന്നുണ്ടോ ഇല്ലയോ എന്ന് പരിശോധിക്കാൻ പോകുന്നു.

ശ്രദ്ധിക്കുക: പരിശോധനയ്ക്കായി ലഭ്യമായ ഒരു സാമ്പിൾ API ഞങ്ങൾ എടുക്കുന്നു. നിങ്ങൾക്ക് ഏതെങ്കിലും PATH തിരഞ്ഞെടുക്കാം അല്ലെങ്കിൽ നിങ്ങളുടെ API റഫർ ചെയ്യാം.

ഉറവിടത്തിനായി ഇവിടെ ക്ലിക്ക് ചെയ്യുക.

#5) ഇപ്പോൾ ഞങ്ങളുടെ അടുത്ത ഘട്ടം ഒരു സൃഷ്‌ടിക്കുക എന്നതാണ്. .feature file.

ആമുഖ വിഭാഗത്തിൽ ചർച്ച ചെയ്തതുപോലെ, .feature file എന്നത് കുക്കുമ്പറിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ച സ്വത്താണ്. ഈ ഫയലിൽ, API ടെസ്റ്റിംഗ് നടത്തുന്നതിന് എക്സിക്യൂട്ട് ചെയ്യേണ്ട ടെസ്റ്റ് സാഹചര്യങ്ങൾ ഞങ്ങൾ എഴുതും.

• നിങ്ങളുടെ പ്രോജക്റ്റിലെ src/test/java എന്ന ഫോൾഡറിലേക്ക് പോകുക.

• അതിൽ വലത് ക്ലിക്ക് ചെയ്‌ത് ഒരു പുതിയ ഫയൽ സൃഷ്‌ടിക്കുക – userDetails.feature. പിന്നെ ഫിനിഷ് ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുക.

ഇപ്പോൾ src/test/java എന്ന ഫോൾഡറിന് താഴെ നിങ്ങൾ ഇനിപ്പറയുന്ന ഫയൽ കാണും. 3>

പച്ച നിറമുള്ള ഐക്കൺ ഞങ്ങൾ ഇപ്പോൾ സൃഷ്‌ടിച്ച കുക്കുമ്പറിലെ .ഫീച്ചർ ഫി ലെയോട് സാമ്യമുള്ളതാണ്.

5>ഫയൽ സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ ടെസ്റ്റ് സാഹചര്യങ്ങൾ എഴുതും, അത് ഇനിപ്പറയുന്ന വിഭാഗത്തിൽ ചർച്ചചെയ്യും.

#6) ഞങ്ങൾക്ക് സാഹചര്യവും ഒപ്പംശൂന്യമായ . ഫീച്ചർ ഫയൽ തയ്യാറാണ്, ഇപ്പോൾ നമുക്ക് നമ്മുടെ ആദ്യ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ആരംഭിക്കാം. നമുക്ക് കോഡിംഗ് ആരംഭിക്കാം

ഞങ്ങൾ ഘട്ടം #5-ൽ സൃഷ്‌ടിച്ച userDetails.feature ഫയലിന് കീഴിൽ കോഡിന്റെ ഇനിപ്പറയുന്ന വരി എഴുതുക:

 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 നിങ്ങളുടെ പ്രോജക്റ്റിൽ

• അതിൽ വലത് ക്ലിക്ക് ചെയ്‌ത് ഒരു പുതിയ ജാവ ഫയൽ സൃഷ്‌ടിക്കുക: 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 റിപ്പോർട്ട് സാഹചര്യങ്ങൾ & പരാമർശിച്ച സാഹചര്യത്തിനായി നടപ്പിലാക്കിയ ടെസ്റ്റ് :

ഉപസംഹാരം

ഈ ട്യൂട്ടോറിയലിൽ, ഞങ്ങൾ API ടെസ്റ്റിംഗും വ്യത്യസ്തമായ പരിശോധനയും ചർച്ച ചെയ്തിട്ടുണ്ട് വിപണിയിൽ ലഭ്യമായ ടൂളുകൾ, കരാട്ടെ ഫ്രെയിംവർക്ക് അതിന്റെ എതിരാളികളുമായി താരതമ്യം ചെയ്യുമ്പോൾ എങ്ങനെ മികച്ച ഓപ്ഷനാണ്.

ഞങ്ങളുടെ ആദ്യ അടിസ്ഥാന ടെസ്റ്റ് സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കാൻ ഞങ്ങൾ ഒരു ഘട്ടം ഘട്ടമായുള്ള സമീപനം പിന്തുടർന്നു. ഒരു .ഫീച്ചർ ഫയൽ സൃഷ്‌ടിക്കുന്നതിനായി ഞങ്ങൾ ഒരു അടിസ്ഥാന Maven പ്രൊജക്‌റ്റ് എക്ലിപ്‌സ് ഐഡിഇയിൽ സൃഷ്‌ടിക്കാൻ തുടങ്ങി, അതിൽ എല്ലാ ടെസ്റ്റിംഗ് സാഹചര്യവും .ഫീച്ചർ ഫയലിൽ സൂചിപ്പിച്ചിരിക്കുന്ന ടെസ്റ്റ് കേസ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള ഒരു റണ്ണർ ഫയലും അടങ്ങിയിരിക്കുന്നു.

ഒന്നിലധികം ഘട്ടങ്ങളുടെ അവസാനം, ഞങ്ങൾക്ക് ടെസ്റ്റ് ഫലങ്ങളുടെ നിർവ്വഹണ റിപ്പോർട്ട് കാണാൻ കഴിയും.

കരാട്ടെ ഫ്രെയിംവർക്ക് ഉപയോഗിച്ച് അവരുടെ ആദ്യ ടെസ്റ്റ് സ്ക്രിപ്റ്റ് എങ്ങനെ നിർമ്മിക്കാമെന്ന് മനസിലാക്കാൻ തുടക്കക്കാർക്ക് ഈ ട്യൂട്ടോറിയൽ സഹായകരമാണെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു. കൂടാതെ API ടെസ്റ്റിംഗ് നടത്തുക. ഈ വിശദമായ ഘട്ടം ഘട്ടമായുള്ളAPI-യിൽ വിവിധ ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനും നടപ്പിലാക്കുന്നതിനുമുള്ള ഒരു മികച്ച മാർഗമാണ് സമീപനം.

NEXT>>

തന്റെ ഒഴിവുസമയങ്ങളിൽ ലീ ഇത് വികസിപ്പിച്ചെടുത്തിരുന്നു.

കരാട്ടെയുടെ രസകരമായ വേരുകൾ പരിശോധിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിലും, ഇപ്പോൾ, വികസിപ്പിച്ചെടുത്ത കരാട്ടെ ടൂൾ നെ കുറിച്ച് പറയാം. പീറ്റർ തോമസ് , API ടെസ്റ്റർമാരുടെ രക്ഷയ്‌ക്കായി വരുന്ന മികച്ച ഉപകരണങ്ങളിലൊന്നാണ്.

BDD സമീപനം പിന്തുടരുന്ന പ്രോഗ്രാം എഴുതുന്ന കുക്കുമ്പർ ശൈലിയാണ് കരാട്ടെ ചട്ടക്കൂട് പിന്തുടരുന്നത്. പ്രോഗ്രാമർമാർ അല്ലാത്തവർക്ക് വാക്യഘടന മനസ്സിലാക്കാൻ എളുപ്പമാണ്. API ഓട്ടോമേഷനും പെർഫോമൻസ് ടെസ്റ്റിംഗും ഒറ്റ ഒറ്റ ഉപകരണമാക്കി സംയോജിപ്പിച്ചിട്ടുള്ള ഒരേയൊരു API ടെസ്റ്റിംഗ് ടൂൾ ഈ ചട്ടക്കൂടാണ്.

ഇത് ഉപയോക്താക്കൾക്ക് ടെസ്റ്റ് കേസുകൾ സമാന്തരമായി എക്സിക്യൂട്ട് ചെയ്യാനും JSON & XML പരിശോധിക്കുന്നു.

ഈ വിവരങ്ങൾ ഉപയോഗിച്ച്, കരാട്ടെ ടൂളിനെ കൂടുതൽ വിശദമായി മനസ്സിലാക്കാൻ ചില പ്രധാന പോയിന്റുകൾ ഊഹിക്കാവുന്നതാണ്:

• പകരം കരാട്ടെ ഒരു BDD ടെസ്റ്റിംഗ് ചട്ടക്കൂടാണ് ഒരു TDD-യുടെ.
• ഇത് പ്രോഗ്രാമർമാർ അല്ലാത്തവർക്ക് എളുപ്പം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു. സാങ്കേതിക പശ്ചാത്തലമോ ശേഷിയോ പരിഗണിക്കാതെ തന്നെ നിരവധി ആളുകൾക്ക് കൂടുതൽ ഉപയോഗവും ആക്‌സസ്സും അനുവദിക്കുന്നതിനാൽ ഈ ഫീച്ചർ ഒരു ഗെയിം ചേഞ്ചറാണ്.
• ഇത് പരീക്ഷ എഴുതാൻ കുക്കുമ്പർ ഫീച്ചർ ഫയലും ഗെർകിൻസ് ഭാഷയും ഉപയോഗിക്കുന്നു. മനസ്സിലാക്കാൻ വളരെ എളുപ്പമാണ്.

ഈ സവിശേഷതകളെല്ലാം തന്നെ ഇതിനെ ഇന്ന് ലഭ്യമായ ഏറ്റവും അനുകൂലമായ ഓട്ടോമേഷൻ ടൂളുകളിൽ ഒന്നാക്കി മാറ്റുന്നു.

കരാട്ടെ ഫ്രെയിംവർക്കിന്റെ ചരിത്രം

സൃഷ്ടിച്ചത് ' പീറ്റർ തോമസിന്റെ 2017-ൽ, ഈ സോഫ്റ്റ്‌വെയർ പരീക്ഷണം നടത്താൻ ലക്ഷ്യമിടുന്നുപ്രവർത്തനങ്ങൾ എല്ലാവർക്കും എളുപ്പത്തിൽ ലഭ്യമാണ്. ഇത് ജാവയിൽ എഴുതിയതാണ്, മിക്ക ആളുകളും അതിന്റെ ഫയലുകളും അതേ ഭാഷയിലായിരിക്കുമെന്ന് പ്രതീക്ഷിച്ചിരുന്നു, എന്നിരുന്നാലും, ഭാഗ്യവശാൽ, അങ്ങനെയല്ല.

പകരം, ഇത് Gherkins ഫയലുകൾ ഉപയോഗിക്കുന്നു, ഇത് ഘർകിൻസ് ഫയലുകളാണ് ഉപയോഗിക്കുന്നത്, കുക്കുമ്പർ ചട്ടക്കൂട്. ഓട്ടോമേഷൻ സോഫ്‌റ്റ്‌വെയർ കുക്കുമ്പറിന്റെ ഒരു വിപുലീകരണമാണ്, അതിനാൽ അതിന്റെ പ്രവർത്തനത്തിൽ ഗെർകിൻസ് ഫയലിന്റെ ഉപയോഗം പാരമ്പര്യമായി ലഭിക്കുന്നു. ഇവ രണ്ടും തമ്മിലുള്ള വലിയ വ്യത്യാസം, പരീക്ഷിക്കുമ്പോൾ കരാട്ടെ ജാവ ഉപയോഗിക്കുന്നില്ല എന്നതാണ്, പക്ഷേ കുക്കുമ്പർ ഉപയോഗിക്കുന്നു.

Gherkins വാക്യഘടന വളരെ വായിക്കാവുന്നതും സമഗ്രവുമായതിനാൽ പ്രോഗ്രാമർ അല്ലാത്തവരെ ഇത് പരിപാലിക്കുന്നതിന്റെ കാരണം ഇതാണ്. ഓട്ടോമേറ്റഡ് എപിഐ ടെസ്റ്റിംഗിന്റെ ലോകത്തേക്ക് പ്രവേശിക്കുന്നതിന് കരാട്ടെ ഏറ്റവും അനുയോജ്യവും ശുപാർശ ചെയ്യുന്നതും ഇതാണ്.

കരാട്ടെ ടെസ്റ്റിംഗ് ഫ്രെയിംവർക്കിന്റെ ചില സവിശേഷതകൾ ഇനിപ്പറയുന്നവയാണ്:

4

എളുപ്പത്തിൽ മനസ്സിലാക്കാവുന്ന ഗെർകിൻസ് ഭാഷ ഉപയോഗിക്കുന്നു.

ഇതിന് ജാവ പോലെയുള്ള സാങ്കേതിക പ്രോഗ്രാമിംഗ് പരിജ്ഞാനം ആവശ്യമില്ല.

ഇത് ജനപ്രിയ കുക്കുമ്പർ മാനദണ്ഡങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.

>ഒരു ചട്ടക്കൂട് സൃഷ്ടിക്കാൻ എളുപ്പമാണ്.

കരാട്ടെ തന്നെ നൽകുന്ന പ്രധാന പ്രവർത്തനമാണ് സമാന്തര പരിശോധന, അതിനാൽ ഞങ്ങൾ Maven, Gradle മുതലായവയെ ആശ്രയിക്കേണ്ടതില്ല.

ടെസ്റ്റ് ഡീബഗ്ഗ് ചെയ്യുന്നതിനുള്ള യുഐ.

മറ്റൊരു ഫയലിൽ നിന്ന് ഒരു ഫീച്ചർ ഫയൽ വിളിക്കുന്നു.

ഇൻ-ഹൗസ് ബിൽറ്റ് ചെയ്ത ഡാറ്റ ഡ്രൈവർ ടെസ്റ്റിംഗിന് പിന്തുണ നൽകുന്നു, അതിനാൽ ബാഹ്യ ചട്ടക്കൂടുകളെ ആശ്രയിക്കേണ്ടതില്ല.

ബിൽറ്റ്-ഇൻ നേറ്റീവ് റെസ്റ്റ്റിപ്പോർട്ടുകൾ. കൂടാതെ, മികച്ച UI റിപ്പോർട്ടുകൾക്കും കൂടുതൽ വ്യക്തതയ്‌ക്കുമായി ഇത് കുക്കുമ്പറുമായി സംയോജിപ്പിക്കാൻ കഴിയും.

വ്യത്യസ്‌ത ടെസ്റ്റിംഗ് പരിതസ്ഥിതികളിൽ (QA, Stage, Prod, Pre-Prod) കോൺഫിഗറേഷൻ മാറുന്നതിനുള്ള ഇൻ-ഹൗസ് പിന്തുണ നൽകുന്നു.

സിഐ/സിഡി സംയോജനത്തിനുള്ള തടസ്സമില്ലാത്ത പിന്തുണ ഉപയോഗപ്രദമാകും.

വിവിധ HTTP കോളുകൾ കൈകാര്യം ചെയ്യാൻ പ്രാപ്തമാണ്:

• വെബ് സോക്കറ്റ് പിന്തുണ
• SOAP അഭ്യർത്ഥന
• HTTP
• ബ്രൗസർ കുക്കി കൈകാര്യം ചെയ്യൽ
• HTTPS
• HTML-ഫോം ഡാറ്റ
• XML അഭ്യർത്ഥന

കരാട്ടെ Vs Rest-Assured താരതമ്യം ചെയ്യുന്നു

Rest Assured : REST സേവനങ്ങൾ പരിശോധിക്കുന്നതിനുള്ള ജാവ അടിസ്ഥാനമാക്കിയുള്ള ലൈബ്രറിയാണിത്. കോഡിന്റെ വരികൾ എഴുതാൻ ഇത് ജാവ ഭാഷ ഉപയോഗിക്കുന്നു. നിരവധി അഭ്യർത്ഥന വിഭാഗങ്ങൾ പരിശോധിക്കുന്നതിന് ഇത് സഹായിക്കുന്നു, ഇത് വ്യത്യസ്‌ത ബിസിനസ്സ് ലോജിക് കോമ്പിനേഷനുകളുടെ സ്ഥിരീകരണത്തിന് കാരണമാകുന്നു.

കരാട്ടെ ഫ്രെയിംവർക്ക് : ഒരു കുക്കുമ്പർ/ഗെർകിൻസ് അടിസ്ഥാനമാക്കിയുള്ള ഉപകരണം, SOAP & REST സേവനങ്ങൾ.

ഇനിപ്പറയുന്ന പട്ടിക, Rest-Assured & കരാട്ടെ ചട്ടക്കൂട്:

S.No	അടിസ്ഥാനം	കരാട്ടെ ഫ്രെയിംവർക്ക്	വിശ്രമം-ഉറപ്പു
1	ഭാഷ	ഇത് കുക്കുമ്പറിന്റെയും ഗേർക്കിൻസിന്റെയും സംയോജനമാണ് ഉപയോഗിക്കുന്നത്	ഇത് ജാവ ഭാഷ ഉപയോഗിക്കുന്നു
2	കോഡ് വലുപ്പം	സാധാരണയായി, കോഡ് കുറവാണ്, കാരണം അത് കുക്കുമ്പർ പോലുള്ള ഘടനയെ പിന്തുടരുന്നു	കോഡിന്റെ ലൈൻ കൂടുതലാണ്ജാവ ഭാഷയുടെ ഉപയോഗം
3	സാങ്കേതിക പരിജ്ഞാനം ആവശ്യമാണ്	പ്രോഗ്രാമർമാർ അല്ലാത്തവർക്ക് എളുപ്പത്തിൽ എഴുതാൻ കഴിയും Gherkins code	Java code എഴുതാൻ സാങ്കേതിക പരിജ്ഞാനം ആവശ്യമാണ്
4	Data-driven Testing	ടെസ്റ്റ്എൻജി ഉപയോഗിക്കേണ്ടതുണ്ട് അല്ലെങ്കിൽ അതേ പിന്തുണയ്‌ക്കുന്നതിന് തത്തുല്യമായത് ആവശ്യമാണ്	ഡാറ്റ പരിശോധനയെ പിന്തുണയ്‌ക്കാൻ ഇൻ-ഹൗസ് ടാഗുകൾ ഉപയോഗിക്കാം
1>5	ഇത് SOAP കോൾ പിന്തുണ നൽകുന്നുണ്ടോ	അതെ, ഇത് നൽകുന്നു	ഇത് ഒരു വിശ്രമ അഭ്യർത്ഥനയുമായി മാത്രം ബന്ധപ്പെട്ടതാണ്
6	സമാന്തര പരിശോധന	അതെ, സമാന്തര റിപ്പോർട്ട് സൃഷ്‌ടിക്കുന്നതിലൂടെ സമാന്തര പരിശോധനയെ എളുപ്പത്തിൽ പിന്തുണയ്‌ക്കുന്നു also	വലിയ അളവിലല്ല. ആളുകൾ ഇത് ചെയ്യാൻ ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, പരാജയ നിരക്ക് വിജയ നിരക്കിനേക്കാൾ കൂടുതലാണ്
7	റിപ്പോർട്ടിംഗ് 23	ഇത് ഇൻ-ഹൗസ് റിപ്പോർട്ടിംഗ് നൽകുന്നു, അതിനാൽ ബാഹ്യ പ്ലഗിന്നുകളെ ആശ്രയിക്കേണ്ടതില്ല. മികച്ച യുഐയ്‌ക്കായി കുക്കുമ്പർ റിപ്പോർട്ടിംഗ് പ്ലഗിനുമായി നമുക്ക് ഇത് സംയോജിപ്പിക്കാം.	Junit, TestNG
8	ബാഹ്യ ഡാറ്റയ്‌ക്കായുള്ള CSV പിന്തുണ	അതെ, കരാട്ടെ 0.9.0	ഇല്ല, ജാവ കോഡോ ലൈബ്രറിയോ ഉപയോഗിക്കണം
9	വെബ് യുഐ ഓട്ടോമേഷൻ	അതെ, കരാട്ടെ 0.9.5 മുതൽ വെബ്-യുഐ ഓട്ടോമേഷൻ സാധ്യമാണ്	ഇല്ല, ഇത് പിന്തുണയ്ക്കുന്നില്ല
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) എക്ലിപ്സ്

ഉപയോഗിക്കുന്ന ഒരു സംയോജിത വികസന പരിസ്ഥിതിയാണ് എക്ലിപ്സ് കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗ് മേഖലയിൽ. ജാവ പ്രോഗ്രാമിംഗിനാണ് ഇത് കൂടുതലും ഉപയോഗിക്കുന്നത്. നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, കരാട്ടെ എഴുതിയിരിക്കുന്നത് ജാവയിലാണ്, അതിനാൽ എപിഐ ടെസ്റ്റ് സോഫ്‌റ്റ്‌വെയറിനായുള്ള ഗോ-ടു ഐഡിഇ എക്ലിപ്‌സ് ആയത് എന്തുകൊണ്ടാണെന്ന് കൂടുതൽ അർത്ഥമാക്കുന്നു. മറ്റൊരു കാരണം, ഇതൊരു ഓപ്പൺ സോഴ്‌സ് ടൂളാണ്, ഈ ടൂൾ തിരഞ്ഞെടുക്കാനുള്ള ശക്തമായ കാരണമാണിത്.

ശ്രദ്ധിക്കുക: ഞങ്ങൾക്ക് IntelliJ, Visual Studio എന്നിവയും മറ്റ് വ്യത്യസ്‌തങ്ങളും ഉപയോഗിക്കാം. എഡിറ്റർമാർ വിപണിയിൽ ലഭ്യമാണ്.

#2) Maven

ഇത് ജാവ പ്രൊജക്റ്റുകൾ നിർമ്മിക്കുന്നതിന് പ്രാഥമികമായി ഉപയോഗിക്കുന്ന ഒരു ബിൽഡ് ഓട്ടോമേഷൻ ടൂളാണ്. കരാട്ടെ പരിതസ്ഥിതി സജ്ജീകരിക്കുന്നതിനും കോഡ് എഴുതുന്നതിനുമുള്ള ഒരു മാർഗമാണിത്. Maven ആവശ്യകതകളോടെ നിങ്ങളുടെ എക്ലിപ്സ് സജ്ജീകരിക്കുന്നതിന്, Maven ഇൻസ്റ്റാളേഷനായി നിങ്ങൾക്ക് ഇവിടെ ക്ലിക്ക് ചെയ്യാം.

Maven-ൽ ജോലി ചെയ്യുമ്പോൾ, കരാട്ടെ ഫ്രെയിംവർക്കിനെ പിന്തുണയ്ക്കാൻ നിങ്ങളെ സഹായിക്കുന്ന Maven ഡിപൻഡൻസികൾ ഉപയോഗിക്കുക.

ഇനിപ്പറയുന്നവ pom.xml-ൽ Maven-നൊപ്പം ഡിപൻഡൻസികൾ ഉപയോഗിക്കും.

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

ശ്രദ്ധിക്കുക: ഏറ്റവും പുതിയ പതിപ്പുകൾMaven റിപ്പോസിറ്ററിയിൽ ലഭ്യമാണ്.

#3) Gradle

Gradle Maven-ന് പകരമാണ്, തുല്യ ശേഷിയിൽ ഉപയോഗിക്കാവുന്നതാണ്. അവയ്‌ക്ക് സമാനതകളും വ്യത്യാസങ്ങളുമുണ്ട്, പക്ഷേ ഞങ്ങളുടെ കരാട്ടെ കോഡുകൾക്കായി ഒരു പരിതസ്ഥിതി സജ്ജീകരിക്കുന്നതിന് തുല്യമായി ഉപയോഗിക്കാനാകും.

ഇത് ഉപയോഗിക്കാൻ എളുപ്പമാണ്, വഴക്കമുള്ളതാണ്, ഞങ്ങളുടെ അപ്ലിക്കേഷന് ചില മോഡുലറൈസേഷനും മാനേജ്‌മെന്റ് ആവശ്യകതകളും ഉള്ളപ്പോൾ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. ഒരു കൂട്ടം പ്ലഗ്-ഇന്നുകൾ. Gradle സജ്ജീകരണ കോഡ് ഇതുപോലെയായിരിക്കും,

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

ശ്രദ്ധിക്കുക: നിങ്ങൾക്ക് ഒന്നുകിൽ MAVEN അല്ലെങ്കിൽ GRADLE ഉപയോഗിക്കാം.

#4) നിങ്ങളുടെ സിസ്റ്റത്തിലെ ജാവ എൻവയോൺമെന്റ് സജ്ജീകരണം

കരാട്ടെ ഫ്രെയിംവർക്ക് സ്ക്രിപ്റ്റുകൾ ഉപയോഗിച്ച് ആരംഭിക്കുന്നതിന് JDK, JRE എൻവയോൺമെന്റ് സജ്ജീകരിക്കേണ്ടതുണ്ട്.

കരാട്ടെ ടെസ്റ്റ് സ്ക്രിപ്റ്റിന്റെ ഘടന

ഒരു കരാട്ടെ ടെസ്റ്റ് സ്‌ക്രിപ്റ്റ് “.ഫീച്ചർ” വിപുലീകരണത്തിന്റെ കൈവശം അറിയപ്പെടുന്നു. ഈ സ്വത്ത് കുക്കുമ്പറിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചതാണ്. ജാവ കൺവെൻഷനിലെ ഫയലുകളുടെ ഓർഗനൈസേഷനും ഒരുപോലെ അനുവദനീയമാണ്. Java പാക്കേജ് കൺവെൻഷനുകൾ അനുസരിച്ച് നിങ്ങളുടെ ഫയലുകൾ ഓർഗനൈസുചെയ്യാൻ നിങ്ങൾക്ക് സ്വാതന്ത്ര്യമുണ്ട്.

എന്നിരുന്നാലും, ജാവ ഇതര ഫയലുകളുടെ സംഭരണം പ്രത്യേകം ചെയ്യണമെന്ന് Maven മാർഗ്ഗനിർദ്ദേശങ്ങൾ നിർദ്ദേശിക്കുന്നു. അവ ഒരു src/test/resources ഘടനയിലാണ് ചെയ്യുന്നത്. ജാവ ഫയലുകൾ src/main/java എന്നതിന് കീഴിലാണ് സൂക്ഷിച്ചിരിക്കുന്നത്.

എന്നാൽ കരാട്ടെ ഫ്രെയിംവർക്കിന്റെ സ്രഷ്‌ടാക്കൾ പറയുന്നതനുസരിച്ച്, ഞങ്ങൾ ജാവ ഫയലുകളും നോൺ-ജാവ ഫയലുകളും ഒരുമിച്ച് സൂക്ഷിക്കുമെന്ന് അവർ ശക്തമായി വിശ്വസിക്കുന്നു. വശം. അവരുടെ അഭിപ്രായത്തിൽ, ശ്രദ്ധിക്കുന്നത് വളരെ എളുപ്പമാണ്*.java, *.ഫീച്ചർ ഫയലുകൾ സാധാരണ Maven ഘടന പിന്തുടരുന്നതിനുപകരം, ഒരുമിച്ച് സൂക്ഷിക്കുമ്പോൾ.

നിങ്ങളുടെ 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 പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ പരിശോധിക്കേണ്ട സാഹചര്യങ്ങൾ 14> ആദ്യത്തെ അടിസ്ഥാന കരാട്ടെ ടെസ്റ്റ് സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കുന്നു

നിങ്ങളുടെ ആദ്യ ടെസ്റ്റ് സ്‌ക്രിപ്റ്റ് സൃഷ്‌ടിക്കുന്നത് ആരംഭിക്കാൻ ഈ വിഭാഗം നിങ്ങളെ സഹായിക്കും, ഇത് കരാട്ടെ ചട്ടക്കൂടിന്റെ രൂപത്തിൽ API-കൾ പരിവർത്തനം ചെയ്യാൻ നിങ്ങളെ സഹായിക്കും.

ഞങ്ങൾ അടിസ്ഥാന കരാട്ടെ ടെസ്റ്റ് സ്ക്രിപ്റ്റുകൾ എഴുതുന്നതിന് മുമ്പ്,നിങ്ങളുടെ മെഷീനിൽ ഇനിപ്പറയുന്ന ആവശ്യകതകൾ ഇൻസ്റ്റാൾ ചെയ്യുക:

• Eclipse IDE
• Maven. ഉചിതമായ മാവൻ പാത സജ്ജമാക്കുക.
• JDK & ജെ.ആർ.ഇ. ഉചിതമായ പാത സജ്ജമാക്കുക.

നമുക്ക് ഘട്ടം ഘട്ടമായുള്ള സമീപനം നോക്കാം:

#1) ഒരു സൃഷ്‌ടിക്കുക പുതിയ MAVEN പ്രൊജക്റ്റ് എക്ലിപ്സ് എഡിറ്ററിൽ

• എക്ലിപ്സ് തുറക്കുക
• ഫയലിൽ ക്ലിക്ക് ചെയ്യുക. പുതിയ പ്രോജക്റ്റ് തിരഞ്ഞെടുക്കുക.

• മേവൻ പ്രോജക്റ്റ് തിരഞ്ഞെടുക്കുക

• തിരഞ്ഞെടുക്കുക വർക്ക്‌സ്‌പെയ്‌സ് ലൊക്കേഷൻ.
• ആർക്കറ്റിപ്പ് തിരഞ്ഞെടുക്കുക (സാധാരണയായി ഞങ്ങൾ " Maven-archetype-quickstart 1.1 " എന്നത് ലളിതമായ Maven പ്രോജക്‌റ്റുകൾക്കായി തിരഞ്ഞെടുക്കുന്നു).
• നൽകുക ഗ്രൂപ്പ് ഐഡി & ആർട്ടിഫാക്റ്റ് ഐഡി (ഞങ്ങളുടെ ഉദാഹരണത്തിൽ ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ ഞങ്ങൾ ഉപയോഗിച്ചു).
  • ഗ്രൂപ്പ് ഐഡി : കരാട്ടെ
  • ആർട്ടിഫാക്റ്റ് ഐഡി: കരാട്ടെടെസ്റ്റ്സ്ക്രിപ്റ്റ് സാമ്പിൾ
• പൂർത്തിയാക്കാൻ ഫിനിഷിൽ ക്ലിക്ക് ചെയ്യുക സജ്ജീകരണം.

#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) നമുക്ക് ഈ സാഹചര്യം മസ്തിഷ്കവൽക്കരിക്കാം, എന്താണ് നമ്മൾ പരീക്ഷിക്കാൻ പോകുന്നത്