• តើអ្វីជាក្របខណ្ឌការ៉ាតេ
• សេចក្តីសន្និដ្ឋាន
  • History Of Karate Framework
• ប្រៀបធៀប Karate Vs Rest-Assured
  • ឧបករណ៍ដែលត្រូវការសម្រាប់ធ្វើការជាមួយ Karate Framework
  • រចនាសម្ព័ន្ធនៃស្គ្រីបតេស្ត Karate
  • ការបង្កើតស្គ្រីបតេស្តការ៉ាតេមូលដ្ឋានដំបូង

ការបង្រៀននេះគឺជាការណែនាំអំពីការធ្វើតេស្ត API ដោយប្រើក្របខណ្ឌ Karate ។ ស្វែងយល់អំពីរចនាសម្ព័ន្ធនៃស្គ្រីបសាកល្បងការ៉ាតេ និងជំហានដើម្បីបង្កើតស្គ្រីបសាកល្បងដំបូង៖

API គឺជាអក្សរកាត់ដែលតំណាងឱ្យចំណុចប្រទាក់កម្មវិធីកម្មវិធី។ នៅក្នុងពាក្យសាមញ្ញ យើងអាចកំណត់វាជាអន្តរការីផ្នែកទន់ដែលអនុញ្ញាតឱ្យទំនាក់ទំនងរវាងកម្មវិធី។

យើងត្រូវការការធ្វើតេស្ត API ដោយសារតែ៖

• លទ្ធផលត្រូវបានបោះពុម្ពលឿនជាងមុន ដូច្នេះហើយកុំរង់ចាំមើលថាតើ API ដំណើរការល្អឬអត់។
• ជាមួយនឹងការឆ្លើយតបកាន់តែលឿន ការដាក់ពង្រាយ APIs ទាំងនេះក៏កាន់តែលឿនផងដែរ ដូច្នេះហើយអនុញ្ញាតឱ្យមានពេលវេលាផ្លាស់ប្តូររហ័ស។
• ការរកឃើញការបរាជ័យដំបូង។ ទោះបីជាមុនពេល UI របស់កម្មវិធីត្រូវបានបង្កើតក៏ដោយ អនុញ្ញាតឱ្យយើងកាត់បន្ថយហានិភ័យ និងកែតម្រូវកំហុស។
• ការចែកចាយទ្រង់ទ្រាយធំអាចធ្វើទៅបានក្នុងរយៈពេលដ៏ខ្លី។

ដើម្បីអាចធ្វើការលើ API Testing យើងមានឧបករណ៍ជាច្រើនដែលមាននៅលើទីផ្សារដូចជា Postman, Mocha និង Chai ។ ទាំងនេះបានបង្ហាញពីលទ្ធផលល្អ និងការប្រើប្រាស់ប្រកបដោយប្រសិទ្ធភាពសម្រាប់ការសាកល្បង APIs ទោះបីជាយ៉ាងណាក៏ដោយ ទាំងនេះគឺជាកូដដែលមានឥទ្ធិពលយ៉ាងខ្លាំង។ ដើម្បី​អាច​ប្រើ​វា​បាន អ្នក​ត្រូវ​តែ​មាន​លក្ខណៈ​បច្ចេកទេស និង​ស៊ាំ​នឹង​ភាសា​កម្មវិធី។

ក្របខណ្ឌ​ការ៉ាតេ​អាច​ដោះស្រាយ​បញ្ហា​នេះ​បាន​យ៉ាង​ល្អ​អំពី​ឧបករណ៍​កម្មវិធី​មុន​របស់​វា។

តើអ្វីជាក្របខណ្ឌការ៉ាតេ

ការ៉ាតេ? តោះនិយាយការ៉ាតេ។ មកពីប្រទេសជប៉ុនមែនទេ? តើ​អ្នក​គិត​អ្វី? ប្រហែលជា Bruce ដ៏អស្ចារ្យស្គ្រីបតេស្តមូលដ្ឋានការ៉ាតេនេះ។

សេណារីយ៉ូ៖

យើងនឹងសាកល្បង API ជាមួយ URL នេះ។

ផ្លូវ៖ api/users/2

វិធីសាស្រ្ត៖ GET

ហើយយើងត្រូវធ្វើឱ្យមានសុពលភាព ថាតើសំណើកំពុងត្រឡប់ លេខកូដជោគជ័យ ( 200) ឬអត់។

ក្នុងន័យសាមញ្ញ យើងគ្រាន់តែនឹងសាកល្បង API គំរូ ដើម្បីមើលថាតើវាត្រូវបានប្រតិបត្តិដោយជោគជ័យឬអត់។

ចំណាំ៖ យើងកំពុងយក API គំរូដែលមានសម្រាប់សាកល្បង។ អ្នកអាចជ្រើសរើសផ្លូវណាមួយ ឬអាចយោងទៅ API របស់អ្នក។

ចុចទីនេះសម្រាប់ប្រភព។

#5) ឥឡូវនេះជំហានបន្ទាប់របស់យើងគឺដើម្បីបង្កើត ឯកសារ .feature ។

ដូចដែលបានពិភាក្សានៅក្នុងផ្នែកណែនាំ ឯកសារ .feature គឺជាទ្រព្យសម្បត្តិដែលត្រូវបានទទួលមរតកពីត្រសក់។ នៅក្នុងឯកសារនេះ យើងនឹងសរសេរអំពីសេណារីយ៉ូសាកល្បងដែលចាំបាច់ត្រូវប្រតិបត្តិសម្រាប់ការអនុវត្តការធ្វើតេស្ត API ។

• ចូលទៅកាន់ថត src/test/java នៅក្នុងគម្រោងរបស់អ្នក។

• ចុចកណ្ដុរស្ដាំលើវា ហើយបង្កើតឯកសារថ្មី – userDetails.feature។ បន្ទាប់មកចុចលើប៊ូតុង Finish។

ឥឡូវនេះអ្នកនឹងឃើញឯកសារខាងក្រោមនៅក្រោមថត src/test/java

រូបតំណាងពណ៌បៃតង ស្រដៀងនឹង .feature 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 ។
• សេណារីយ៉ូ៖ រាល់ឯកសារលក្ខណៈពិសេសដែលអ្នកនឹងឃើញនឹងមានយ៉ាងហោចណាស់លក្ខណៈពិសេសមួយ (ទោះបីជាវាអាចផ្តល់ឱ្យ ច្រើន សេណារីយ៉ូ) . វាគឺជាការពិពណ៌នាអំពីករណីសាកល្បង។
• បានផ្តល់ឱ្យ៖ វាជាជំហានដែលចាំបាច់ត្រូវប្រតិបត្តិ មុនពេលជំហានសាកល្បងផ្សេងទៀតត្រូវបានអនុវត្ត។ វាគឺជាសកម្មភាពចាំបាច់ដែលត្រូវអនុវត្ត។
• ពេលណា៖ វាបញ្ជាក់លក្ខខណ្ឌដែលគួរបំពេញដើម្បីអនុវត្តជំហានសាកល្បងបន្ទាប់។
• បន្ទាប់មក៖ វាប្រាប់យើងថាអ្វីដែលគួរកើតឡើងក្នុងករណីដែលលក្ខខណ្ឌដែលបានរៀបរាប់នៅក្នុង នៅពេលដែល ត្រូវបានពេញចិត្ត។

ចំណាំ៖ ពាក្យគន្លឹះដែលបានរៀបរាប់ខាងលើទាំងអស់គឺ ពីភាសា Gherkins ។ ទាំងនេះគឺជាវិធីស្តង់ដារនៃការសរសេរស្គ្រីបសាកល្បងដោយប្រើត្រសក់។

ហើយពាក្យមួយចំនួនទៀតដែលប្រើក្នុងឯកសារលក្ខណៈពិសេសគឺ៖

• 200៖ វាគឺជាលេខកូដស្ថានភាព/ការឆ្លើយតបដែលយើងជាការរំពឹងទុក (ចុចទីនេះសម្រាប់បញ្ជីលេខកូដស្ថានភាព)
• ទទួលបាន៖ វាគឺជាវិធីសាស្ត្រ API ដូចជា POST, PUT ជាដើម។

យើងសង្ឃឹមថាការពន្យល់នេះ វាងាយស្រួលសម្រាប់អ្នកក្នុងការយល់។ ឥឡូវនេះ អ្នកនឹងអាចទាក់ទងទៅនឹងអ្វីដែលត្រូវបានសរសេរនៅក្នុងឯកសារខាងលើ។

ឥឡូវនេះយើងត្រូវបង្កើតឯកសារ TestRunner.java

ដូចដែលបានពន្យល់ខាងលើ ផ្នែក Cucumber ត្រូវការឯកសារ Runner ដែលនឹងត្រូវបានទាមទារដើម្បីប្រតិបត្តិឯកសារ .feature ដែលមានសេណារីយ៉ូសាកល្បង។

• ចូលទៅកាន់ Folder src/test/java នៅក្នុងគម្រោងរបស់អ្នក

• ចុចខាងស្តាំលើវា ហើយបង្កើតឯកសារ Java ថ្មី៖ TestRunner.java
• នៅពេលឯកសារត្រូវបានបង្កើត ដាក់បន្ទាត់កូដខាងក្រោមវា៖

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

• Test Runner គឺជាឯកសារដែលឥឡូវនេះនឹងត្រូវបានប្រតិបត្តិដើម្បីអនុវត្ត សេណារីយ៉ូដែលចង់បានដែលត្រូវបានសរសេរនៅក្រោមជំហាន #5។

#7) ឥឡូវនេះយើងរួចរាល់ជាមួយនឹងឯកសារទាំងពីរ TestRunner.Java និង userDeatils.feature ។ កិច្ចការតែមួយគត់ដែលនៅសេសសល់សម្រាប់យើងគឺ រត់ ស្គ្រីប។

• ចូលទៅកាន់ឯកសារ TestRunner.java ហើយចុចកណ្ដុរស្ដាំលើឯកសារដូចបង្ហាញក្នុងរូបភាពខាងក្រោម។

• ជ្រើសរើស រត់ជា -> Junit Test
• ឥឡូវ​នេះ ពេល​បាន​ជ្រើសរើស អ្នក​នឹង​ចាប់​ផ្ដើម​សង្កេត​ឃើញ​ថា​ករណី​សាកល្បង​បាន​ចាប់​ផ្ដើម​ហើយ។
• រង់ចាំ​ឲ្យ​ស្គ្រីប​សាកល្បង​ដំណើរការ។ នៅពេលរួចរាល់ អ្នកនឹងសង្កេតឃើញអ្វីមួយដូចបង្ហាញក្នុងរូបភាពខាងក្រោមនៅក្នុងបង្អួចរបស់អ្នក។

• ជាចុងក្រោយ យើងអាចនិយាយបានថាថាយើងបានបង្កើតដោយជោគជ័យនូវ Test Script ជាមូលដ្ឋានដំបូងរបស់យើងដោយប្រើ Karate Framework។

#8) ចុងក្រោយគឺ Karate framework ក៏ផ្តល់បទបង្ហាញរបាយការណ៍ HTML សម្រាប់ការប្រតិបត្តិដែលត្រូវបានអនុវត្ត។

• ចូលទៅកាន់ថតគោលដៅ -> surefire-reports-> នៅទីនេះអ្នកនឹងឃើញរបាយការណ៍ HTML របស់អ្នកដែលអ្នកអាចបើកបាន។

** យើងក៏សូមណែនាំអ្នកឱ្យបើកដូចគ្នាដោយប្រើ Chrome កម្មវិធីរុករកតាមអ៊ីនធឺណិតសម្រាប់រូបរាង និងអារម្មណ៍កាន់តែប្រសើរ។

• ការតាមដានរបាយការណ៍ HTML នឹងត្រូវបានបង្ហាញដល់អ្នកដោយពណ៌នាអំពី សេណារីយ៉ូ & តេស្ត ដែលត្រូវបានប្រតិបត្តិសម្រាប់សេណារីយ៉ូដែលបានរៀបរាប់៖

សេចក្តីសន្និដ្ឋាន

នៅក្នុងមេរៀននេះ យើងបានពិភាក្សាអំពីការធ្វើតេស្ត API ការធ្វើតេស្តផ្សេងៗ ឧបករណ៍ដែលមាននៅលើទីផ្សារ និងរបៀបដែល Karate Framework គឺជាជម្រើសប្រសើរជាងបើប្រៀបធៀបទៅនឹងសមភាគីរបស់វា។

យើងបានធ្វើតាមវិធីសាស្រ្តមួយជំហានម្តងមួយៗដើម្បីបង្កើតស្គ្រីបសាកល្បងមូលដ្ឋានដំបូងរបស់យើង។ យើងបានចាប់ផ្តើមជាមួយនឹងការបង្កើត គម្រោង Maven ជាមូលដ្ឋាននៅក្នុង Eclipse IDE ដើម្បីបង្កើតឯកសារ .feature ដែលមានសេណារីយ៉ូសាកល្បងទាំងអស់ និងឯកសារ Runner ដើម្បីប្រតិបត្តិករណីសាកល្បងដែលបានរៀបរាប់នៅក្នុងឯកសារ .feature ។

នៅចុងបញ្ចប់នៃជំហានជាច្រើន យើងអាចឃើញរបាយការណ៍ប្រតិបត្តិនៃលទ្ធផលតេស្ត។

យើងសង្ឃឹមថា ការបង្រៀននេះមានប្រយោជន៍សម្រាប់អ្នកចាប់ផ្តើមដំបូងក្នុងការរៀនពីរបៀបបង្កើតស្គ្រីបសាកល្បងដំបូងរបស់ពួកគេដោយប្រើ Karate Framework និងអនុវត្តការធ្វើតេស្ត API ។ នេះជាជំហានលម្អិតវិធីសាស្រ្តគឺជាវិធីដ៏អស្ចារ្យមួយដើម្បីដំណើរការ និងអនុវត្តការធ្វើតេស្តផ្សេងៗនៅលើ API។

NEXT>>

Lee បានបង្កើតវានៅពេលទំនេររបស់គាត់។

ទោះបីជាយើងចង់ស្វែងយល់ពីឫសគល់ដ៏គួរឱ្យចាប់អារម្មណ៍របស់ Karate ក៏ដោយ សម្រាប់ពេលនេះ ចូរនិយាយអំពី ឧបករណ៍ Karate ដែលត្រូវបានបង្កើតឡើង ដោយ Peter Thomas ដែលជាឧបករណ៍ដ៏អស្ចារ្យមួយដែលបានមកជួយសង្គ្រោះអ្នកសាកល្បង API។

ក្របខ័ណ្ឌការ៉ាតេធ្វើតាមរចនាប័ទ្មត្រសក់នៃការសរសេរកម្មវិធីដែលធ្វើតាមវិធីសាស្រ្ត BDD ។ វាក្យសម្ព័ន្ធងាយស្រួលយល់ដោយអ្នកមិនមែនជាអ្នកសរសេរកម្មវិធី។ ហើយក្របខ័ណ្ឌនេះគឺជាឧបករណ៍សាកល្បង API តែមួយគត់ដែលបានរួមបញ្ចូលគ្នានូវ API Automation និងការធ្វើតេស្តការអនុវត្តទៅក្នុងឧបករណ៍ឯករាជ្យតែមួយ។

វាផ្តល់ឱ្យអ្នកប្រើប្រាស់នូវសមត្ថភាពក្នុងការប្រតិបត្តិករណីសាកល្បងនៅក្នុងប៉ារ៉ាឡែល និងអនុវត្ត JSON & ការត្រួតពិនិត្យ XML។

ជាមួយនឹងព័ត៌មាននេះ ចំណុចសំខាន់ៗមួយចំនួនអាចត្រូវបានគណនាដើម្បីស្វែងយល់បន្ថែមអំពីឧបករណ៍ Karate យ៉ាងលម្អិត៖

• Karate គឺជាក្របខ័ណ្ឌសាកល្បង BDD ជំនួសវិញ នៃ TDD។
• វាត្រូវបានរចនាឡើងដើម្បីងាយស្រួលសម្រាប់អ្នកដែលមិនមែនជាអ្នកសរសេរកម្មវិធី។ មុខងារនេះគឺជាកម្មវិធីផ្លាស់ប្តូរហ្គេមព្រោះវាអនុញ្ញាតឱ្យមានការប្រើប្រាស់ និងការចូលប្រើប្រាស់កាន់តែច្រើនដោយមនុស្សជាច្រើនដោយមិនគិតពីផ្ទៃខាងក្រោយបច្ចេកទេស ឬសមត្ថភាពរបស់ពួកគេ។
• វាប្រើប្រាស់ឯកសារមុខងារ Cucumber និងភាសា Gherkins ដើម្បីសរសេរការសាកល្បងដែលជា ងាយស្រួលយល់ណាស់។

មុខងារទាំងអស់នេះធ្វើឱ្យវាក្លាយជាឧបករណ៍ស្វ័យប្រវត្តិកម្មដ៏អំណោយផលបំផុតមួយដែលមានសព្វថ្ងៃនេះ។

History Of Karate Framework

បង្កើតដោយ ' Peter Thomas' ក្នុងឆ្នាំ 2017 កម្មវិធីនេះមានគោលបំណងធ្វើការសាកល្បងមុខងារអាចរកបានសម្រាប់អ្នករាល់គ្នា។ វាត្រូវបានសរសេរជាភាសា Java ហើយមនុស្សភាគច្រើនរំពឹងថាឯកសាររបស់វាក៏ជាភាសាដូចគ្នាដែរ ប៉ុន្តែជាសំណាងល្អ វាមិនមែនជាករណីនោះទេ។

ផ្ទុយទៅវិញ វាប្រើឯកសារ Gherkins ដែលជាលទ្ធផលនៃទំនាក់ទំនងរបស់វាជាមួយ ក្របខណ្ឌត្រសក់។ កម្មវិធីស្វ័យប្រវត្តិកម្មគឺជាផ្នែកបន្ថែមនៃត្រសក់ ដូច្នេះទទួលមរតកពីការប្រើប្រាស់ឯកសារ Gherkins ក្នុងប្រតិបត្តិការរបស់វា។ ភាពខុសគ្នាខ្លាំងរវាងអ្នកទាំងពីរគឺថា Karate មិនប្រើ Java ខណៈពេលកំពុងសាកល្បង ប៉ុន្តែ Cucumber ធ្វើបាន។

នេះជាហេតុផលដែលវាផ្តល់ប្រយោជន៍ដល់អ្នកដែលមិនមែនជាអ្នកសរសេរកម្មវិធី ដោយសារវាក្យសម្ព័ន្ធ Gherkins គឺអាចអានបាន និងទូលំទូលាយ។ នេះជាហេតុផលដែល Karate គឺសមស្របបំផុត និងត្រូវបានណែនាំសម្រាប់ការចូលទៅក្នុងពិភពនៃការធ្វើតេស្ត API ដោយស្វ័យប្រវត្តិ។

ប្រើភាសា Gherkins ដែលងាយយល់។

វាមិនត្រូវការចំណេះដឹងផ្នែកបច្ចេកទេសដូចជា Java ទេ។

វាផ្អែកលើស្តង់ដារ Cucumber ដ៏ពេញនិយម។

ងាយស្រួលក្នុងការបង្កើតក្របខ័ណ្ឌមួយ។

ការធ្វើតេស្តប៉ារ៉ាឡែលគឺជាមុខងារស្នូលដែលត្រូវបានផ្តល់ដោយ Karate ខ្លួនវា ដូច្នេះហើយយើងមិនចាំបាច់ពឹងផ្អែកលើ Maven, Gradle ជាដើម។

UI សម្រាប់បំបាត់កំហុសការសាកល្បង។

ការហៅឯកសារលក្ខណៈពិសេសពីឯកសារផ្សេងទៀត។

ផ្តល់ការគាំទ្រសម្រាប់ការធ្វើតេស្តកម្មវិធីបញ្ជាទិន្នន័យដែលត្រូវបានបង្កើតឡើងនៅក្នុងផ្ទះ ដូច្នេះមិនចាំបាច់ពឹងផ្អែកលើក្របខ័ណ្ឌខាងក្រៅទេ។

កន្លែងសម្រាកដើមដែលមានស្រាប់របាយការណ៍។ លើសពីនេះ វាអាចត្រូវបានរួមបញ្ចូលជាមួយ Cucumber សម្រាប់របាយការណ៍ UI កាន់តែប្រសើរ និងភាពច្បាស់លាស់បន្ថែមទៀត។

ផ្តល់ការគាំទ្រក្នុងផ្ទះសម្រាប់ការផ្លាស់ប្តូរការកំណត់នៅទូទាំងបរិយាកាសសាកល្បងផ្សេងៗគ្នា (QA, Stage, Prod, Pre-Prod)។

ការ​គាំទ្រ​ដោយ​គ្មាន​ថ្នេរ​សម្រាប់​ការ​រួម​បញ្ចូល CI/CD ដែល​អាច​មាន​ប្រយោជន៍។

អាច​គ្រប់គ្រង​ការ​ហៅ HTTP ផ្សេងៗ៖

• ការ​គាំទ្រ​រន្ធ​បណ្ដាញ
• សំណើ SOAP
• HTTP
• ការដោះស្រាយខូគីកម្មវិធីរុករក
• HTTPS
• ទិន្នន័យទម្រង់ HTML
• សំណើ XML

ប្រៀបធៀប Karate Vs Rest-Assured

Rest Assured ៖ វាជាបណ្ណាល័យដែលមានមូលដ្ឋានលើ Java ដើម្បីសាកល្បងសេវាកម្ម REST ។ វាប្រើភាសា Java សម្រាប់សរសេរបន្ទាត់កូដ។ វាជួយក្នុងការសាកល្បងប្រភេទសំណើជាច្រើន ដែលជាលទ្ធផលបន្ថែមក្នុងការផ្ទៀងផ្ទាត់ការរួមបញ្ចូលតក្កវិជ្ជាអាជីវកម្មផ្សេងៗគ្នា។

Karate Framework ៖ ឧបករណ៍ផ្អែកលើត្រសក់/Gherkins ដែលប្រើសម្រាប់ការធ្វើតេស្តសម្រាប់ SOAP & សេវាកម្ម REST។

តារាងខាងក្រោមបង្ហាញពីភាពខុសគ្នាលេចធ្លោមួយចំនួនទៀតរវាង Rest-Assured & ក្របខណ្ឌការ៉ាតេ៖

20

S.No	មូលដ្ឋាន	ក្របខណ្ឌការ៉ាតេ	ធានាដោយ REST
1	ភាសា	វាប្រើការរួមបញ្ចូលគ្នានៃត្រសក់ និងហ្គឺគីន	វាប្រើភាសា Java
2	ទំហំកូដ	ជាធម្មតា បន្ទាត់នៃ កូដគឺតិចជាង ដោយសារវាធ្វើតាមរចនាសម្ព័នដូចត្រសក់	បន្ទាត់នៃកូដគឺកាន់តែច្រើន ដោយសារវាពាក់ព័ន្ធនឹងការប្រើប្រាស់ភាសា Java
3	ត្រូវការចំណេះដឹងបច្ចេកទេស	អ្នកមិនសរសេរកម្មវិធីអាចសរសេរយ៉ាងងាយស្រួល កូដ Gherkins	ចំនេះដឹងបច្ចេកទេសគឺត្រូវបានទាមទារដើម្បីសរសេរកូដ Java
4	ការធ្វើតេស្តដោយទិន្នន័យ	ត្រូវប្រើ TestNG ឬសមមូលដើម្បីគាំទ្រដូចគ្នា	ស្លាកក្នុងផ្ទះអាចត្រូវបានប្រើដើម្បីគាំទ្រការធ្វើតេស្តទិន្នន័យ
5	តើវាផ្តល់ជំនួយការហៅទូរសព្ទ SOAP	បាទ/ចាស វាផ្តល់	វាទាក់ទងតែសំណើរ REST
6	ការធ្វើតេស្តប៉ារ៉ាឡែល	បាទ/ចាស ការធ្វើតេស្តប៉ារ៉ាឡែលត្រូវបានគាំទ្រយ៉ាងងាយស្រួលជាមួយនឹងការបង្កើតរបាយការណ៍ប៉ារ៉ាឡែល ផងដែរ	មិនមែនក្នុងកម្រិតធំទេ។ ទោះបីជាមនុស្សបានព្យាយាមធ្វើវាក៏ដោយ អត្រាបរាជ័យគឺច្រើនជាងអត្រាជោគជ័យ
7	ការរាយការណ៍	វាផ្តល់នូវការរាយការណ៍ក្នុងផ្ទះ ដូច្នេះហើយមិនចាំបាច់ពឹងផ្អែកលើកម្មវិធីជំនួយខាងក្រៅទេ។ យើងថែមទាំងអាចបញ្ចូលវាជាមួយកម្មវិធីជំនួយរាយការណ៍ Cucumber សម្រាប់ UI កាន់តែប្រសើរ។	ចាំបាច់ត្រូវពឹងផ្អែកលើកម្មវិធីជំនួយខាងក្រៅដូចជា Junit, TestNG
8	ជំនួយ CSV សម្រាប់ទិន្នន័យខាងក្រៅ	បាទ/ចាស ពី Karate 0.9.0	ទេ ត្រូវប្រើ Java Code ឬបណ្ណាល័យ
9	Web UI Automation	បាទ/ចាស ពី Karate 0.9.5 Web-UI Automation គឺអាចធ្វើទៅបាន	ទេ វាមិនត្រូវបានគាំទ្រទេ
10	គំរូ GET	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"));

ដូច្នេះហើយ ដូចដែលបានបង្ហាញដោយ ភាពខុសគ្នាខាងលើ វាមានសុវត្ថិភាពក្នុងការនិយាយថា Karate គឺជារឿងងាយស្រួលបំផុតមួយដែលនរណាម្នាក់អាចធ្វើបាន។

ឧបករណ៍ដែលត្រូវការសម្រាប់ធ្វើការជាមួយ Karate Framework

ឥឡូវនេះ ដោយសារយើងទទួលបានចំណេះដឹងជាមូលដ្ឋានរបស់យើងអំពី ក្របខណ្ឌ Karate ជាចំនុច សូមអោយយើងពិនិត្យមើលដំណើរការ និងឧបករណ៍ដែលត្រូវការក្នុងការរៀបចំបរិស្ថាន Karate ។

#1) Eclipse

Eclipse គឺជាបរិស្ថានអភិវឌ្ឍន៍រួមបញ្ចូលគ្នាដែលប្រើ ក្នុងវិស័យសរសេរកម្មវិធីកុំព្យូទ័រ។ វាភាគច្រើនប្រើសម្រាប់ Java Programming ។ ដូចដែលបានរៀបរាប់ខាងលើ Karate ត្រូវបានសរសេរជាភាសា Java ដូច្នេះវាកាន់តែយល់ច្បាស់ថាហេតុអ្វីបានជា Eclipse គឺជា IDE សម្រាប់កម្មវិធីសាកល្បង API ។ ហេតុផលមួយទៀតគឺថាវាជាឧបករណ៍ប្រភពបើកចំហ ហើយនេះគឺជាហេតុផលដ៏រឹងមាំមួយក្នុងការជ្រើសរើសឧបករណ៍នេះ។

ចំណាំ៖ យើងថែមទាំងអាចប្រើ IntelliJ, Visual Studio និងផ្សេងទៀតផងដែរ។ កម្មវិធីនិពន្ធដែលមាននៅលើទីផ្សារ។

#2) Maven

នេះគឺជាឧបករណ៍បង្កើតស្វ័យប្រវត្តិកម្មដែលប្រើជាចម្បងសម្រាប់ការសាងសង់គម្រោង Java។ វា​ជា​វិធី​មួយ​ក្នុង​ការ​បង្កើត​បរិស្ថាន​ការ៉ាតេ និង​ការ​សរសេរ​កូដ។ ដើម្បីដំឡើង Eclipse របស់អ្នកជាមួយនឹងតម្រូវការ Maven អ្នកអាចចុចនៅទីនេះសម្រាប់ការដំឡើង Maven។

ខណៈពេលកំពុងធ្វើការនៅ Maven សូមប្រើ Maven dependencies ដែលនឹងជួយអ្នកគាំទ្រ Karate Framework។

ខាងក្រោមនេះ ភាពអាស្រ័យនឹងត្រូវបានប្រើជាមួយ Maven ក្នុង pom.xml។

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

ចំណាំ៖ កំណែចុងក្រោយបំផុតអាចនឹងមាននៅក្នុងឃ្លាំង Maven។

#3) Gradle

Gradle គឺជាជម្រើសជំនួស Maven ហើយអាចប្រើក្នុងទំហំស្មើគ្នា។ ពួកវាមានភាពស្រដៀងគ្នា និងភាពខុសគ្នារបស់ពួកគេ ប៉ុន្តែអាចប្រើស្មើៗគ្នាក្នុងការរៀបចំបរិយាកាសសម្រាប់កូដ Karate របស់យើង។

វាកាន់តែងាយស្រួលប្រើ មានភាពបត់បែន និងត្រូវបានណែនាំឱ្យប្រើនៅពេលដែលកម្មវិធីរបស់យើងមានតម្រូវការម៉ូឌុល និងការគ្រប់គ្រងមួយចំនួនជាមួយ បណ្តុំនៃកម្មវិធីជំនួយ។ លេខកូដដំឡើង Gradle នឹងមើលទៅដូចនេះ

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

ចំណាំ៖ អ្នកអាចប្រើ MAVEN ឬ GRADLE។

#4) ការដំឡើង Java Environment នៅក្នុងប្រព័ន្ធរបស់អ្នក

ត្រូវរៀបចំបរិស្ថាន JDK និង JRE ដើម្បីចាប់ផ្តើមជាមួយស្គ្រីប Karate Framework។

រចនាសម្ព័ន្ធនៃស្គ្រីបតេស្ត Karate

ស្គ្រីបសាកល្បងការ៉ាតេត្រូវបានគេស្គាល់សម្រាប់ការកាន់កាប់ផ្នែកបន្ថែម “.feature” ។ ទ្រព្យសម្បត្តិនេះត្រូវបានទទួលមរតកពីត្រសក់។ ការរៀបចំឯកសារនៅក្នុងអនុសញ្ញា Java ក៏ត្រូវបានអនុញ្ញាតដូចគ្នាដែរ។ អ្នក​មាន​សេរីភាព​ក្នុង​ការ​រៀបចំ​ឯកសារ​របស់​អ្នក​ដោយ​យោង​តាម​អនុសញ្ញា​កញ្ចប់ Java។

ទោះ​ជា​យ៉ាង​ណា គោលការណ៍​ណែនាំ Maven ណែនាំ​ថា​ការ​ផ្ទុក​ឯកសារ​ដែល​មិន​មែន​ជា Java ត្រូវ​បាន​ធ្វើ​ដោយ​ឡែក​ពី​គ្នា។ ពួកវាត្រូវបានធ្វើនៅក្នុងរចនាសម្ព័ន្ធ src/test/resources ។ ហើយឯកសារ Java ត្រូវបានរក្សាទុកនៅក្រោម src/main/java ។

ប៉ុន្តែយោងទៅតាមអ្នកបង្កើត Karate Framework ពួកគេជឿជាក់យ៉ាងមុតមាំថាយើងរក្សាទុកទាំងឯកសារ Java និងមិនមែន Java នៅក្បែរគ្នា។ ចំហៀង។ ដូចដែលពួកគេមើលទៅវាកាន់តែងាយស្រួលក្នុងការរកមើលឯកសារ *.java និង *.feature នៅពេលដែលពួកវាត្រូវបានរក្សាទុកជាមួយគ្នា ជាជាងធ្វើតាមរចនាសម្ព័ន្ធ Maven ស្តង់ដារ។

នេះអាចត្រូវបានធ្វើបានយ៉ាងងាយស្រួលដោយការកែប្រែ pom.xml របស់អ្នកដូចខាងក្រោម (សម្រាប់ Maven):

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

ខាងក្រោមនេះគឺជាគ្រោងនៃរចនាសម្ព័ន្ធទូទៅនៃក្របខណ្ឌការ៉ាតេ៖

ឥឡូវនេះ ចាប់តាំងពីក្របខណ្ឌការ៉ាតេនេះកំពុងប្រើ ឯកសារ Runner ដែលត្រូវការនៅក្នុង Cucumber ដើម្បីដំណើរការឯកសារលក្ខណៈពិសេស ដូច្នេះការសរសេរភាគច្រើននឹងធ្វើតាមស្តង់ដារ Cucumber ។

ប៉ុន្តែ មិនដូច Cucumber ជំហានមិនតម្រូវឱ្យមាននិយមន័យច្បាស់លាស់នៅក្នុង Karate និងអ្វីដែល នៅក្នុងវេន បង្កើនភាពបត់បែន និងភាពងាយស្រួលនៃប្រតិបត្តិការ។ យើងមិនចាំបាច់បន្ថែមកាវបន្ថែមដែលយើងត្រូវបន្ថែមជាធម្មតាទេ នៅពេលដែលយើងធ្វើតាម Cucumber framework។

ថ្នាក់ "Runner" ភាគច្រើនត្រូវបានគេហៅថា TestRunner.java។

បន្ទាប់មកឯកសារ TestRunner.java នឹងយកទម្រង់៖

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

ហើយនិយាយអំពីឯកសារ .feature វាមានការធ្វើតេស្តទាំងអស់ សេណារីយ៉ូ​ដែល​ត្រូវ​ការ​សាកល្បង​ដើម្បី​ធ្វើ​ឱ្យ​ប្រាកដ​ថា API កំពុង​ដំណើរ​ការ​តាម​តម្រូវ​ការ​ដែល​បាន​រំពឹង​ទុក។

ឯកសារ *.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

ការបង្កើតស្គ្រីបតេស្តការ៉ាតេមូលដ្ឋានដំបូង

ផ្នែកនេះនឹងជួយអ្នកចាប់ផ្តើមជាមួយនឹងការបង្កើតស្គ្រីបសាកល្បងដំបូងរបស់អ្នក ដែលនឹងមានប្រយោជន៍សម្រាប់អ្នកក្នុងការបំប្លែង APIs ក្នុងទម្រង់ជាក្របខណ្ឌការ៉ាតេ។

មុនពេលយើងសរសេរស្គ្រីបសាកល្បងការ៉ាតេមូលដ្ឋានសូមដំឡើងតម្រូវការខាងក្រោមនៅលើម៉ាស៊ីនរបស់អ្នក៖

• Eclipse IDE
• Maven។ កំណត់ផ្លូវ Maven ដែលសមស្រប។
• JDK & JRE កំណត់ផ្លូវសមស្រប។

តោះមើលវិធីសាស្រ្តជាជំហានៗ៖

#1) បង្កើត គម្រោង MAVEN ថ្មីនៅក្នុង Eclipse Editor

• បើក Eclipse
• ចុចលើឯកសារ។ ជ្រើសរើសគម្រោងថ្មី។

• ជ្រើសរើសគម្រោង Maven

• ជ្រើសរើស ទីតាំងកន្លែងធ្វើការ។
• ជ្រើសរើស Archetype (ជាធម្មតាយើងជ្រើសរើស “ Maven-archetype-quickstart 1.1 ” សម្រាប់គម្រោងសាមញ្ញ Maven)។
• ផ្តល់ លេខសម្គាល់ក្រុម & លេខសម្គាល់វត្ថុបុរាណ (យើងបានប្រើតម្លៃខាងក្រោមក្នុងឧទាហរណ៍របស់យើង)។
  • លេខសម្គាល់ក្រុម ៖ Karate
  • លេខសម្គាល់វត្ថុបុរាណ៖ KarateTestScriptsSample
• ចុចលើ Finish ដើម្បីបំពេញ ការដំឡើង។

#2) នៅពេលដែលបានបង្កើតរួចហើយ ឥឡូវនេះអ្នកនឹងអាចឃើញរចនាសម្ព័ន្ធខាងក្រោមនៅក្នុងបង្អួច Project Explorer។

#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) តោះបំផុសគំនិតអំពីសេណារីយ៉ូ តើយើងនឹងសាកល្បងអ្វីខ្លះនៅក្នុង