Gruntle Software & Testing

ಇವರು Stewart Tristianಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ ಮಾರ್ಗದರ್ಶಕರು

ಈ ಟ್ಯುಟೋರಿಯಲ್ ಕರಾಟೆ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು 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>

ಹಸಿರು ಬಣ್ಣದ ಐಕಾನ್ ನಾವು ಈಗಷ್ಟೇ ರಚಿಸಿದ ಸೌತೆಕಾಯಿಯಲ್ಲಿ .ಫೀಚರ್ fi le ಅನ್ನು ಹೋಲುತ್ತದೆ.

    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ಗೆ ಹೋಗಿ 2> ನಿಮ್ಮ ಯೋಜನೆಯಲ್ಲಿ

  • ಅದರ ಮೇಲೆ ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಹೊಸ ಜಾವಾ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ: 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-ವರದಿಗಳು-> ನೀವು ತೆರೆಯಬಹುದಾದ ನಿಮ್ಮ HTML ವರದಿಯನ್ನು ಇಲ್ಲಿ ನೀವು ನೋಡುತ್ತೀರಿ.

** Chrome ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ತೆರೆಯಲು ನಾವು ನಿಮಗೆ ಸಲಹೆ ನೀಡುತ್ತೇವೆ ಉತ್ತಮ ನೋಟ ಮತ್ತು ಅನುಭವಕ್ಕಾಗಿ ಬ್ರೌಸರ್.

  • ಕೆಳಗಿನ HTML ವರದಿಯನ್ನು ಸನ್ನಿವೇಶಗಳು & ಉಲ್ಲೇಖಿಸಲಾದ ಸನ್ನಿವೇಶಕ್ಕಾಗಿ ಪರೀಕ್ಷೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ:

ತೀರ್ಮಾನ

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನಾವು API ಪರೀಕ್ಷೆ, ವಿಭಿನ್ನ ಪರೀಕ್ಷೆಯನ್ನು ಚರ್ಚಿಸಿದ್ದೇವೆ ಮಾರುಕಟ್ಟೆಯಲ್ಲಿ ಲಭ್ಯವಿರುವ ಪರಿಕರಗಳು ಮತ್ತು ಅದರ ಕೌಂಟರ್‌ಪಾರ್ಟ್‌ಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಕರಾಟೆ ಫ್ರೇಮ್‌ವರ್ಕ್ ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.

ನಮ್ಮ ಮೊದಲ ಮೂಲಭೂತ ಪರೀಕ್ಷಾ ಸ್ಕ್ರಿಪ್ಟ್ ರಚಿಸಲು ನಾವು ಹಂತ-ಹಂತದ ವಿಧಾನವನ್ನು ಅನುಸರಿಸಿದ್ದೇವೆ. .ಫೀಚರ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲು ಎಕ್ಲಿಪ್ಸ್ IDE ನಲ್ಲಿ ಮೂಲಭೂತ Maven ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವುದರೊಂದಿಗೆ ನಾವು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ, ಇದು ಎಲ್ಲಾ ಪರೀಕ್ಷೆಯ ಸನ್ನಿವೇಶವನ್ನು ಮತ್ತು .ಫೀಚರ್ ಫೈಲ್‌ನಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾದ ಪರೀಕ್ಷಾ ಪ್ರಕರಣವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ರನ್ನರ್ ಫೈಲ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ.

ಬಹು ಹಂತಗಳ ಕೊನೆಯಲ್ಲಿ, ನಾವು ಪರೀಕ್ಷಾ ಫಲಿತಾಂಶಗಳ ಮರಣದಂಡನೆ ವರದಿಯನ್ನು ನೋಡಬಹುದು.

ಕರಾಟೆ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ತಮ್ಮ ಮೊದಲ ಪರೀಕ್ಷಾ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂಬುದನ್ನು ಕಲಿಯಲು ಆರಂಭಿಕರಿಗಾಗಿ ಈ ಟ್ಯುಟೋರಿಯಲ್ ಸಹಾಯಕವಾಗಿದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ. ಮತ್ತು API ಪರೀಕ್ಷೆಯನ್ನು ಕೈಗೊಳ್ಳಿ. ಈ ವಿವರವಾದ ಹಂತ-ಹಂತAPI ನಲ್ಲಿ ವಿವಿಧ ಪರೀಕ್ಷೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ವಿಧಾನವು ಅದ್ಭುತ ಮಾರ್ಗವಾಗಿದೆ.

ಮುಂದೆ>>

ಲೀ ತನ್ನ ಬಿಡುವಿನ ವೇಳೆಯಲ್ಲಿ ಇದನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ್ದಾರೆ.

ನಾವು ಕರಾಟೆಯ ಆಸಕ್ತಿದಾಯಕ ಬೇರುಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಬಯಸುತ್ತೇವೆ, ಸದ್ಯಕ್ಕೆ, ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಕರಾಟೆ ಟೂಲ್ ಕುರಿತು ಮಾತನಾಡೋಣ ಪೀಟರ್ ಥಾಮಸ್ ಮೂಲಕ, API ಪರೀಕ್ಷಕರ ರಕ್ಷಣೆಗೆ ಬರುವ ಉತ್ತಮ ಸಾಧನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.

ಕರಾಟೆ ಚೌಕಟ್ಟು BDD ವಿಧಾನವನ್ನು ಅನುಸರಿಸುವ ಪ್ರೋಗ್ರಾಂ ಬರೆಯುವ ಸೌತೆಕಾಯಿ ಶೈಲಿಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ. ಪ್ರೋಗ್ರಾಮರ್ ಅಲ್ಲದವರಿಂದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗಿದೆ. ಮತ್ತು ಈ ಫ್ರೇಮ್‌ವರ್ಕ್ API ಆಟೊಮೇಷನ್ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆಯನ್ನು ಒಂದೇ ಸ್ವತಂತ್ರ ಸಾಧನವಾಗಿ ಸಂಯೋಜಿಸಿದ ಏಕೈಕ API ಪರೀಕ್ಷಾ ಸಾಧನವಾಗಿದೆ.

ಇದು ಬಳಕೆದಾರರಿಗೆ ಪರೀಕ್ಷಾ ಪ್ರಕರಣಗಳನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮತ್ತು JSON & XML ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಈ ಮಾಹಿತಿಯೊಂದಿಗೆ, ಕರಾಟೆ ಪರಿಕರವನ್ನು ವಿವರವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕೆಲವು ಪ್ರಮುಖ ಅಂಶಗಳನ್ನು ಕಳೆಯಬಹುದು:

  • ಕರಾಟೆ ಬದಲಿಗೆ BDD ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟಾಗಿದೆ TDD ನ.
  • ಇದನ್ನು ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಲ್ಲದವರಿಗೆ ಸುಲಭವಾಗುವಂತೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಈ ವೈಶಿಷ್ಟ್ಯವು ಆಟ-ಬದಲಾವಣೆಯಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಅನೇಕ ಜನರು ತಮ್ಮ ತಾಂತ್ರಿಕ ಹಿನ್ನೆಲೆ ಅಥವಾ ಸಾಮರ್ಥ್ಯವನ್ನು ಲೆಕ್ಕಿಸದೆ ಹೆಚ್ಚಿನ ಬಳಕೆ ಮತ್ತು ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
  • ಇದು ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯಲು ಸೌತೆಕಾಯಿ ವೈಶಿಷ್ಟ್ಯದ ಫೈಲ್ ಮತ್ತು ಘರ್ಕಿನ್ಸ್ ಭಾಷೆಯನ್ನು ಬಳಸುತ್ತದೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ತುಂಬಾ ಸುಲಭ.

ಈ ಎಲ್ಲಾ ವೈಶಿಷ್ಟ್ಯಗಳು ಇಂದು ಲಭ್ಯವಿರುವ ಅತ್ಯಂತ ಅನುಕೂಲಕರವಾದ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಸಾಧನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.

ಕರಾಟೆ ಚೌಕಟ್ಟಿನ ಇತಿಹಾಸ

ರಚಿಸಿದವರು ' ಪೀಟರ್ ಥಾಮಸ್' 2017 ರಲ್ಲಿ, ಈ ಸಾಫ್ಟ್‌ವೇರ್ ಪರೀಕ್ಷೆಯನ್ನು ಮಾಡುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆಎಲ್ಲರಿಗೂ ಸುಲಭವಾಗಿ ಲಭ್ಯವಿರುವ ಕಾರ್ಯಗಳು. ಇದನ್ನು ಜಾವಾದಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಜನರು ಅದರ ಫೈಲ್‌ಗಳು ಅದೇ ಭಾಷೆಯಲ್ಲಿ ಇರಬೇಕೆಂದು ನಿರೀಕ್ಷಿಸಿದ್ದರು, ಆದಾಗ್ಯೂ, ಅದೃಷ್ಟವಶಾತ್, ಅದು ಹಾಗಲ್ಲ.

ಬದಲಿಗೆ, ಇದು ಘರ್ಕಿನ್ಸ್ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಅದರೊಂದಿಗಿನ ಸಂಬಂಧದ ಫಲಿತಾಂಶವಾಗಿದೆ. ಸೌತೆಕಾಯಿ ಚೌಕಟ್ಟು. ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಸಾಫ್ಟ್‌ವೇರ್ ಸೌತೆಕಾಯಿಯ ವಿಸ್ತರಣೆಯಾಗಿದೆ, ಆದ್ದರಿಂದ ಅದರ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ಘರ್ಕಿನ್ಸ್ ಫೈಲ್‌ನ ಬಳಕೆಯನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ. ಎರಡರ ನಡುವಿನ ದೊಡ್ಡ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಕರಾಟೆ ಪರೀಕ್ಷೆ ಮಾಡುವಾಗ ಜಾವಾವನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಆದರೆ ಸೌತೆಕಾಯಿ ಮಾಡುತ್ತದೆ.

ಘರ್ಕಿನ್ಸ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಸೂಪರ್ ಓದಬಲ್ಲ ಮತ್ತು ಸಮಗ್ರವಾಗಿರುವುದರಿಂದ ಇದು ಪ್ರೋಗ್ರಾಮರ್-ಅಲ್ಲದವರನ್ನು ಪೂರೈಸಲು ಇದೇ ಕಾರಣ. ಈ ಕಾರಣಕ್ಕಾಗಿಯೇ ಕರಾಟೆಯು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ API ಪರೀಕ್ಷೆಯ ಜಗತ್ತಿನಲ್ಲಿ ಪ್ರವೇಶವನ್ನು ಮಾಡಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.

ಕೆಳಗಿನವು ಕರಾಟೆ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟಿನ ಕೆಲವು ವೈಶಿಷ್ಟ್ಯಗಳಾಗಿವೆ:

  • ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಘರ್ಕಿನ್ಸ್ ಭಾಷೆಯನ್ನು ಬಳಸುತ್ತದೆ.
  • ಇದಕ್ಕೆ ಜಾವಾದಂತಹ ಯಾವುದೇ ತಾಂತ್ರಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಜ್ಞಾನದ ಅಗತ್ಯವಿಲ್ಲ.
  • ಇದು ಜನಪ್ರಿಯ ಸೌತೆಕಾಯಿ ಮಾನದಂಡಗಳನ್ನು ಆಧರಿಸಿದೆ.
  • ಚೌಕಟ್ಟನ್ನು ರಚಿಸುವುದು ಸುಲಭ.
  • ಸಮಾನಾಂತರ ಪರೀಕ್ಷೆಯು ಕರಾಟೆಯಿಂದಲೇ ಒದಗಿಸಲಾದ ಪ್ರಮುಖ ಕಾರ್ಯಚಟುವಟಿಕೆಯಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಮಾವೆನ್, ಗ್ರ್ಯಾಡಲ್ , ಇತ್ಯಾದಿಗಳನ್ನು ಅವಲಂಬಿಸಬೇಕಾಗಿಲ್ಲ.
  • ಪರೀಕ್ಷೆಯನ್ನು ಡೀಬಗ್ ಮಾಡಲು UI.
  • ಮತ್ತೊಂದು ಫೈಲ್‌ನಿಂದ ವೈಶಿಷ್ಟ್ಯದ ಫೈಲ್ ಅನ್ನು ಕರೆಯುವುದು.
  • ಮನೆಯಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಡೇಟಾ ಡ್ರೈವರ್ ಪರೀಕ್ಷೆಗೆ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಬಾಹ್ಯ ಚೌಕಟ್ಟುಗಳನ್ನು ಅವಲಂಬಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
  • ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಥಳೀಯ ವಿಶ್ರಾಂತಿವರದಿಗಳು. ಜೊತೆಗೆ, ಉತ್ತಮ UI ವರದಿಗಳು ಮತ್ತು ಹೆಚ್ಚಿನ ಸ್ಪಷ್ಟತೆಗಾಗಿ ಇದನ್ನು ಸೌತೆಕಾಯಿಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು.
  • ವಿವಿಧ ಪರೀಕ್ಷಾ ಪರಿಸರಗಳಲ್ಲಿ (QA, ಹಂತ, ಉತ್ಪನ್ನ, ಪೂರ್ವ-ಉತ್ಪನ್ನ) ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಆಂತರಿಕ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ.
  • CI/CD ಏಕೀಕರಣಕ್ಕೆ ತಡೆರಹಿತ ಬೆಂಬಲವು ಉಪಯುಕ್ತವಾಗಿದೆ.
  • ವಿವಿಧ HTTP ಕರೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಸಾಮರ್ಥ್ಯ:
    • ವೆಬ್ ಸಾಕೆಟ್ ಬೆಂಬಲ
    • SOAP ವಿನಂತಿ
    • HTTP
    • ಬ್ರೌಸರ್ ಕುಕೀ ನಿರ್ವಹಣೆ
    • HTTPS
    • HTML-ಫಾರ್ಮ್ ಡೇಟಾ
    • XML ವಿನಂತಿ

ಕರಾಟೆ Vs Rest-Assured

Rest Assured ಹೋಲಿಕೆ: REST ಸೇವೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಇದು Java-ಆಧಾರಿತ ಲೈಬ್ರರಿಯಾಗಿದೆ. ಇದು ಕೋಡ್‌ನ ಸಾಲುಗಳನ್ನು ಬರೆಯಲು ಜಾವಾ ಭಾಷೆಯನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ಹಲವಾರು ವಿನಂತಿಯ ವರ್ಗಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಇದು ವಿವಿಧ ವ್ಯವಹಾರ ತರ್ಕ ಸಂಯೋಜನೆಗಳ ಪರಿಶೀಲನೆಯಲ್ಲಿ ಮತ್ತಷ್ಟು ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆ.

ಕರಾಟೆ ಫ್ರೇಮ್‌ವರ್ಕ್ : ಸೌತೆಕಾಯಿ/ಘರ್ಕಿನ್ಸ್ ಆಧಾರಿತ ಸಾಧನ, SOAP & REST ಸೇವೆಗಳು.

ಕೆಳಗಿನ ಕೋಷ್ಟಕವು ರೆಸ್ಟ್-ಆಶ್ಯೂರ್ಡ್ & ನಡುವಿನ ಕೆಲವು ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಕರಾಟೆ ಫ್ರೇಮ್‌ವರ್ಕ್:

S.ಸಂ ಆಧಾರ ಕರಾಟೆ ಫ್ರೇಮ್‌ವರ್ಕ್ ವಿಶ್ರಾಂತಿ-ಖಾತ್ರಿ
1 ಭಾಷೆ ಇದು ಸೌತೆಕಾಯಿ ಮತ್ತು ಗೆರ್ಕಿನ್ಸ್ ಸಂಯೋಜನೆಯನ್ನು ಬಳಸುತ್ತದೆ ಇದು ಜಾವಾ ಭಾಷೆಯನ್ನು ಬಳಸುತ್ತದೆ
2 ಕೋಡ್ ಗಾತ್ರ ಸಾಮಾನ್ಯವಾಗಿ, ಕೋಡ್ ಕಡಿಮೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಸೌತೆಕಾಯಿಯಂತಹ ರಚನೆಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ ಕೋಡ್ನ ಸಾಲು ಹೆಚ್ಚು ಏಕೆಂದರೆ ಅದು ಒಳಗೊಂಡಿರುತ್ತದೆಜಾವಾ ಭಾಷೆಯ ಬಳಕೆ
3 ತಾಂತ್ರಿಕ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಲ್ಲದವರು ಸುಲಭವಾಗಿ ಬರೆಯಬಹುದು ಘರ್ಕಿನ್ಸ್ ಕೋಡ್ ಜಾವಾ ಕೋಡ್ ಬರೆಯಲು ತಾಂತ್ರಿಕ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ
4 ಡೇಟಾ-ಚಾಲಿತ ಪರೀಕ್ಷೆ ಟೆಸ್ಟ್‌ಎನ್‌ಜಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ ಅಥವಾ ಅದನ್ನು ಬೆಂಬಲಿಸಲು ಸಮಾನವಾಗಿದೆ ಡೇಟಾ ಪರೀಕ್ಷೆಯನ್ನು ಬೆಂಬಲಿಸಲು ಇನ್-ಹೌಸ್ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಬಳಸಬಹುದು
1>5 ಇದು SOAP ಕರೆ ಬೆಂಬಲವನ್ನು ನೀಡುತ್ತದೆಯೇ ಹೌದು, ಇದು ಒದಗಿಸುತ್ತದೆ ಇದು ಕೇವಲ REST ವಿನಂತಿಗೆ ಸಂಬಂಧಿಸಿದೆ
6 ಸಮಾನಾಂತರ ಪರೀಕ್ಷೆ ಹೌದು, ಸಮಾನಾಂತರ ವರದಿ ರಚನೆಯೊಂದಿಗೆ ಸಮಾನಾಂತರ ಪರೀಕ್ಷೆಯನ್ನು ಸುಲಭವಾಗಿ ಬೆಂಬಲಿಸಲಾಗುತ್ತದೆ ಸಹ ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಅಲ್ಲ. ಜನರು ಇದನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೂ, ವೈಫಲ್ಯದ ಪ್ರಮಾಣವು ಯಶಸ್ಸಿನ ಪ್ರಮಾಣಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿದೆ
7 ವರದಿ ಇದು ಆಂತರಿಕ ವರದಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಬಾಹ್ಯ ಪ್ಲಗಿನ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರಬೇಕಾಗಿಲ್ಲ. ಉತ್ತಮ UI ಗಾಗಿ ಸೌತೆಕಾಯಿ ವರದಿ ಮಾಡುವ ಪ್ಲಗಿನ್‌ನೊಂದಿಗೆ ನಾವು ಅದನ್ನು ಸಂಯೋಜಿಸಬಹುದು. Junit, TestNG
8 ನಂತಹ ಬಾಹ್ಯ ಪ್ಲಗಿನ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರಬೇಕು 23> ಬಾಹ್ಯ ಡೇಟಾಗೆ CSV ಬೆಂಬಲ ಹೌದು, ಕರಾಟೆ 0.9.0 ಇಲ್ಲ, ಜಾವಾ ಕೋಡ್ ಅಥವಾ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಬೇಕು
9 ವೆಬ್ UI ಆಟೊಮೇಷನ್ ಹೌದು, ಕರಾಟೆ 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, ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋ, ಮತ್ತು ಇತರ ವಿವಿಧವನ್ನು ಸಹ ಬಳಸಬಹುದು. ಸಂಪಾದಕರು ಮಾರುಕಟ್ಟೆಯಲ್ಲಿ ಲಭ್ಯವಿದೆ.

#2) ಮಾವೆನ್

ಇದು ಜಾವಾ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಾಥಮಿಕವಾಗಿ ಬಳಸಲಾಗುವ ಬಿಲ್ಡ್ ಆಟೊಮೇಷನ್ ಸಾಧನವಾಗಿದೆ. ಕರಾಟೆ ಪರಿಸರವನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ಕೋಡ್ ಬರೆಯಲು ಇದು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. 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 ಮಾವೆನ್‌ಗೆ ಪರ್ಯಾಯವಾಗಿದೆ ಮತ್ತು ಸಮಾನ ಸಾಮರ್ಥ್ಯದಲ್ಲಿ ಬಳಸಬಹುದು. ಅವುಗಳು ತಮ್ಮ ಹೋಲಿಕೆಗಳು ಮತ್ತು ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೊಂದಿವೆ ಆದರೆ ನಮ್ಮ ಕರಾಟೆ ಕೋಡ್‌ಗಳಿಗೆ ಪರಿಸರವನ್ನು ಹೊಂದಿಸುವಲ್ಲಿ ಸಮಾನವಾಗಿ ಬಳಸಬಹುದು.

ಇದು ಬಳಸಲು ಸುಲಭವಾಗಿದೆ, ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೆಲವು ಮಾಡ್ಯುಲರೈಸೇಶನ್ ಮತ್ತು ನಿರ್ವಹಣೆ ಅಗತ್ಯತೆಗಳನ್ನು ಹೊಂದಿರುವಾಗ ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ ಪ್ಲಗ್-ಇನ್‌ಗಳ ಸಮೂಹ. Gradle ಸೆಟಪ್ ಕೋಡ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ,

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

ಗಮನಿಸಿ: ನೀವು MAVEN ಅಥವಾ GRADLE ಅನ್ನು ಬಳಸಬಹುದು.

#4) ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ Java ಎನ್ವಿರಾನ್ಮೆಂಟ್ ಸೆಟಪ್

ಕರಾಟೆ ಫ್ರೇಮ್ವರ್ಕ್ ಸ್ಕ್ರಿಪ್ಟ್ಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲು JDK ಮತ್ತು JRE ಪರಿಸರವನ್ನು ಹೊಂದಿಸುವ ಅಗತ್ಯವಿದೆ.

ಕರಾಟೆ ಟೆಸ್ಟ್ ಸ್ಕ್ರಿಪ್ಟ್ನ ರಚನೆ

ಕರಾಟೆ ಪರೀಕ್ಷಾ ಸ್ಕ್ರಿಪ್ಟ್ ".ಫೀಚರ್" ವಿಸ್ತರಣೆಯ ಸ್ವಾಧೀನಕ್ಕೆ ಹೆಸರುವಾಸಿಯಾಗಿದೆ. ಈ ಆಸ್ತಿ ಸೌತೆಕಾಯಿಯಿಂದ ಆನುವಂಶಿಕವಾಗಿದೆ. ಜಾವಾ ಸಮಾವೇಶದಲ್ಲಿ ಫೈಲ್‌ಗಳ ಸಂಘಟನೆಯನ್ನು ಸಹ ಸಮಾನವಾಗಿ ಅನುಮತಿಸಲಾಗಿದೆ. ಜಾವಾ ಪ್ಯಾಕೇಜ್ ಸಂಪ್ರದಾಯಗಳ ಪ್ರಕಾರ ನಿಮ್ಮ ಫೈಲ್‌ಗಳನ್ನು ಸಂಘಟಿಸಲು ನೀವು ಸ್ವತಂತ್ರರಾಗಿದ್ದೀರಿ.

ಆದಾಗ್ಯೂ, ಜಾವಾ ಅಲ್ಲದ ಫೈಲ್‌ಗಳ ಸಂಗ್ರಹಣೆಯನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಮಾಡಬೇಕೆಂದು ಮಾವೆನ್ ಮಾರ್ಗಸೂಚಿಗಳು ಸೂಚಿಸುತ್ತವೆ. ಅವುಗಳನ್ನು src/test/resources ರಚನೆಯಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ. ಮತ್ತು ಜಾವಾ ಫೈಲ್‌ಗಳನ್ನು src/main/java ಅಡಿಯಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ.

ಆದರೆ ಕರಾಟೆ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನ ರಚನೆಕಾರರ ಪ್ರಕಾರ, ನಾವು ಜಾವಾ ಮತ್ತು ಜಾವಾ ಅಲ್ಲದ ಫೈಲ್‌ಗಳನ್ನು ಪಕ್ಕದಲ್ಲಿರಿಸಿಕೊಳ್ಳುತ್ತೇವೆ ಎಂದು ಅವರು ಬಲವಾಗಿ ನಂಬುತ್ತಾರೆ. ಬದಿ. ಅವರ ಪ್ರಕಾರ, ಅದನ್ನು ನೋಡಿಕೊಳ್ಳುವುದು ತುಂಬಾ ಸುಲಭ*.java ಮತ್ತು *.ಫೀಚರ್ ಫೈಲ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಇರಿಸಿದಾಗ, ಪ್ರಮಾಣಿತ ಮಾವೆನ್ ರಚನೆಯನ್ನು ಅನುಸರಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ.

ನಿಮ್ಮ 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 & JRE. ಸೂಕ್ತವಾದ ಮಾರ್ಗವನ್ನು ಹೊಂದಿಸಿ.

ಹಂತ-ಹಂತದ ವಿಧಾನವನ್ನು ನೋಡೋಣ:

#1) ರಚಿಸಿ ಹೊಸ MAVEN ಎಕ್ಲಿಪ್ಸ್ ಎಡಿಟರ್‌ನಲ್ಲಿ ಪ್ರಾಜೆಕ್ಟ್

  • ಓಪನ್ ಎಕ್ಲಿಪ್ಸ್
  • ಫೈಲ್ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ. ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ.

  • ಮಾವೆನ್ ಪ್ರಾಜೆಕ್ಟ್ ಆಯ್ಕೆಮಾಡಿ

  • ಆಯ್ಕೆ ಮಾಡಿ ಕಾರ್ಯಸ್ಥಳದ ಸ್ಥಳ.
  • ಆರ್ಕಿಟೈಪ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ (ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ಸರಳ ಮಾವೆನ್ ಯೋಜನೆಗಳಿಗಾಗಿ “ ಮಾವೆನ್-ಆರ್ಕಿಟೈಪ್-ಕ್ವಿಕ್‌ಸ್ಟಾರ್ಟ್ 1.1 ” ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ).
  • ಒದಗಿಸುವುದು ಗುಂಪು ID & ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ ಐಡಿ (ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ಈ ಕೆಳಗಿನ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಿದ್ದೇವೆ).
    • ಗುಂಪು ID : ಕರಾಟೆ
    • ಕಲಾಕೃತಿ ID: KarateTestScriptsSample
  • ಪೂರ್ಣಗೊಳಿಸಲು ಮುಕ್ತಾಯದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ ಸೆಟಪ್.

#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) ಸನ್ನಿವೇಶವನ್ನು ಬುದ್ದಿಮತ್ತೆ ಮಾಡೋಣ, ನಾವು ಏನನ್ನು ಪರೀಕ್ಷಿಸಲಿದ್ದೇವೆ

ಮೇಲಕ್ಕೆ ಸ್ಕ್ರೋಲ್ ಮಾಡಿ