Gruntle Software & Testing

ਦੁਆਰਾ Stewart Tristianਤੇ ਪੋਸਟ ਕੀਤਾ ਵਿੱਚ ਪੋਸਟ ਕੀਤਾ ਗਾਈਡ

ਇਹ ਟਿਊਟੋਰਿਅਲ ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ API ਟੈਸਟਿੰਗ ਲਈ ਇੱਕ ਜਾਣ-ਪਛਾਣ ਹੈ। ਕਰਾਟੇ ਟੈਸਟ ਸਕ੍ਰਿਪਟ ਦੀ ਬਣਤਰ ਅਤੇ ਪਹਿਲੀ ਟੈਸਟ ਸਕ੍ਰਿਪਟ ਬਣਾਉਣ ਦੇ ਕਦਮਾਂ ਬਾਰੇ ਜਾਣੋ:

API ਇੱਕ ਸੰਖੇਪ ਰੂਪ ਹੈ ਜਿਸਦਾ ਅਰਥ ਹੈ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਇੰਟਰਫੇਸ। ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਅਸੀਂ ਇਸਨੂੰ ਇੱਕ ਸਾਫਟਵੇਅਰ ਵਿਚੋਲੇ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿਚਕਾਰ ਸੰਚਾਰ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਸਾਨੂੰ API ਟੈਸਟਿੰਗ ਦੀ ਲੋੜ ਹੈ ਕਿਉਂਕਿ:

  • ਨਤੀਜੇ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰਕਾਸ਼ਿਤ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ ਇਹ ਦੇਖਣ ਲਈ ਹੋਰ ਇੰਤਜ਼ਾਰ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿ ਕੀ API ਠੀਕ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।
  • ਤੇਜ਼ ਜਵਾਬ ਦੇ ਨਾਲ, ਇਹਨਾਂ APIs ਦੀ ਤੈਨਾਤੀ ਵੀ ਤੇਜ਼ ਹੋ ਜਾਂਦੀ ਹੈ, ਇਸਲਈ ਜਲਦੀ ਬਦਲਣ ਦੇ ਸਮੇਂ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।
  • ਅਗੇਤੀ ਅਸਫਲਤਾ ਦਾ ਪਤਾ ਲਗਾਉਣਾ, ਐਪ ਦੇ UI ਦੇ ਬਣਾਏ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ, ਸਾਨੂੰ ਜੋਖਮਾਂ ਨੂੰ ਘਟਾਉਣ ਅਤੇ ਨੁਕਸ ਨੂੰ ਠੀਕ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿਓ।
  • ਥੋੜ੍ਹੇ ਸਮੇਂ ਵਿੱਚ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਡਿਲੀਵਰੀ ਸੰਭਵ ਹੈ।

ਏਪੀਆਈ ਟੈਸਟਿੰਗ 'ਤੇ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਸਾਡੇ ਕੋਲ ਮਾਰਕੀਟ ਵਿੱਚ ਪੋਸਟਮੈਨ, ਮੋਚਾ ਅਤੇ ਚਾਈ ਵਰਗੇ ਵੱਖ-ਵੱਖ ਟੂਲ ਉਪਲਬਧ ਹਨ। ਇਹਨਾਂ ਨੇ APIs ਦੀ ਜਾਂਚ ਲਈ ਚੰਗੇ ਨਤੀਜੇ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਵਰਤੋਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ ਹੈ, ਹਾਲਾਂਕਿ, ਇਹ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕੋਡ ਪ੍ਰਭਾਵਿਤ ਹਨ। ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਕਿਸੇ ਨੂੰ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਸਹੀ ਅਤੇ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਜਾਣੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਆਪਣੇ ਪਿਛਲੇ ਸਾਫਟਵੇਅਰ ਟੂਲਸ ਦੇ ਇਸ ਮੁੱਦੇ ਨੂੰ ਸੁੰਦਰਤਾ ਨਾਲ ਹੱਲ ਕਰਦਾ ਹੈ।

ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਕੀ ਹੈ

ਕਰਾਟੇ? ਕਰਾਟੇ ਦੀ ਗੱਲ ਕਰੀਏ। ਕੀ ਇਹ ਜਪਾਨ ਤੋਂ ਹੈ? ਤੁਹਾਨੂੰ ਕੀ ਲੱਗਦਾ ਹੈ? ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਮਹਾਨ ਬਰੂਸਇਹ ਕਰਾਟੇ ਬੇਸਿਕ ਟੈਸਟ ਸਕ੍ਰਿਪਟ।

ਸੀਨਰੀਓ:

ਅਸੀਂ ਇਸ URL ਦੇ ਨਾਲ ਇੱਕ API ਦੀ ਜਾਂਚ ਕਰਾਂਗੇ।

ਪਾਥ: api/users/2

ਵਿਧੀ: GET

ਅਤੇ ਸਾਨੂੰ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਕੀ ਬੇਨਤੀ ਇੱਕ ਸਫਲਤਾ ਕੋਡ ਵਾਪਸ ਕਰ ਰਹੀ ਹੈ ( 200) ਜਾਂ ਨਹੀਂ।

ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਅਸੀਂ ਇਹ ਦੇਖਣ ਲਈ ਇੱਕ ਨਮੂਨਾ API ਦੀ ਜਾਂਚ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ ਕਿ ਇਹ ਸਫਲਤਾਪੂਰਵਕ ਚਲਾਇਆ ਜਾ ਰਿਹਾ ਹੈ ਜਾਂ ਨਹੀਂ।

ਨੋਟ: ਅਸੀਂ ਇੱਕ ਨਮੂਨਾ API ਲੈ ਰਹੇ ਹਾਂ ਜੋ ਜਾਂਚ ਲਈ ਉਪਲਬਧ ਹੈ। ਤੁਸੀਂ ਕੋਈ ਵੀ PATH ਚੁਣ ਸਕਦੇ ਹੋ ਜਾਂ ਆਪਣੇ API ਦਾ ਹਵਾਲਾ ਦੇ ਸਕਦੇ ਹੋ।

ਸਰੋਤ ਲਈ ਇੱਥੇ ਕਲਿੱਕ ਕਰੋ।

#5) ਹੁਣ ਸਾਡਾ ਅਗਲਾ ਕਦਮ ਇੱਕ ਬਣਾਉਣਾ ਹੋਵੇਗਾ। .feature ਫਾਈਲ।

ਜਿਵੇਂ ਕਿ ਜਾਣ-ਪਛਾਣ ਭਾਗ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਗਈ ਹੈ, .feature ਫਾਈਲ ਉਹ ਸੰਪਤੀ ਹੈ ਜੋ ਖੀਰੇ ਤੋਂ ਵਿਰਾਸਤ ਵਿੱਚ ਮਿਲੀ ਹੈ। ਇਸ ਫਾਈਲ ਵਿੱਚ, ਅਸੀਂ ਉਹਨਾਂ ਟੈਸਟ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਲਿਖਾਂਗੇ ਜੋ 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 ਵਿਕਲਪ।
  • ਦ੍ਰਿਸ਼: ਹਰ ਵਿਸ਼ੇਸ਼ਤਾ ਫਾਈਲ ਜੋ ਤੁਸੀਂ ਦੇਖੋਗੇ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹੋਵੇਗੀ (ਹਾਲਾਂਕਿ ਇਹ ਮਲਟੀਪਲ ਸੀਨੇਰੀਓ ਦੇ ਸਕਦਾ ਹੈ) . ਇਹ ਟੈਸਟ ਕੇਸ ਦਾ ਵਰਣਨ ਹੈ।
  • ਦਿੱਤਾ ਗਿਆ: ਇਹ ਉਹ ਪੜਾਅ ਹੈ ਜਿਸ ਨੂੰ ਕਿਸੇ ਹੋਰ ਟੈਸਟ ਪੜਾਅ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰਾ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਲਾਜ਼ਮੀ ਤੌਰ 'ਤੇ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਕਾਰਵਾਈ ਹੈ।
  • ਕਦੋਂ: ਇਹ ਉਸ ਸ਼ਰਤ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਅਗਲੇ ਟੈਸਟ ਪੜਾਅ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਪੂਰਾ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
  • ਫਿਰ: ਇਹ ਸਾਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਜਦੋਂ ਸੰਤੁਸ਼ਟ ਹੋਣ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਨੋਟ: ਉੱਪਰ ਦਿੱਤੇ ਸਾਰੇ ਕੀਵਰਡ ਹਨ Gherkins ਭਾਸ਼ਾ ਤੋਂ. ਇਹ ਖੀਰੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਲਿਖਣ ਦਾ ਮਿਆਰੀ ਤਰੀਕਾ ਹੈ।

ਅਤੇ ਫੀਚਰ ਫਾਈਲ ਵਿੱਚ ਵਰਤੇ ਗਏ ਕੁਝ ਹੋਰ ਸ਼ਬਦ ਹਨ:

  • 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-reports-> ਇੱਥੇ ਤੁਸੀਂ ਆਪਣੀ HTML ਰਿਪੋਰਟ ਦੇਖੋਗੇ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ।

** ਅਸੀਂ ਤੁਹਾਨੂੰ Chrome ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਖੋਲ੍ਹਣ ਦਾ ਸੁਝਾਅ ਵੀ ਦੇਵਾਂਗੇ। ਬਿਹਤਰ ਦਿੱਖ ਅਤੇ ਮਹਿਸੂਸ ਕਰਨ ਲਈ ਬ੍ਰਾਊਜ਼ਰ।

  • ਹੇਠਾਂ ਦਿੱਤੀ ਗਈ HTML ਰਿਪੋਰਟ ਤੁਹਾਨੂੰ ਸੀਨੇਰੀਓਜ਼ & ਟੈਸਟ ਜੋ ਕਿ ਦੱਸੇ ਗਏ ਦ੍ਰਿਸ਼ ਲਈ ਚਲਾਇਆ ਗਿਆ ਹੈ:

ਸਿੱਟਾ

ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ, ਅਸੀਂ API ਟੈਸਟਿੰਗ, ਵੱਖ-ਵੱਖ ਟੈਸਟਿੰਗ ਬਾਰੇ ਚਰਚਾ ਕੀਤੀ ਹੈ। ਮਾਰਕਿਟ ਵਿੱਚ ਉਪਲਬਧ ਟੂਲ, ਅਤੇ ਕਿਸ ਤਰ੍ਹਾਂ ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਇਸਦੇ ਹਮਰੁਤਬਾ ਦੇ ਮੁਕਾਬਲੇ ਇੱਕ ਬਿਹਤਰ ਵਿਕਲਪ ਹੈ।

ਅਸੀਂ ਆਪਣੀ ਪਹਿਲੀ ਬੁਨਿਆਦੀ ਟੈਸਟ ਸਕ੍ਰਿਪਟ ਬਣਾਉਣ ਲਈ ਇੱਕ ਕਦਮ-ਦਰ-ਕਦਮ ਪਹੁੰਚ ਅਪਣਾਈ ਹੈ। ਅਸੀਂ ਇੱਕ .feature ਫਾਈਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਬੁਨਿਆਦੀ Eclipse IDE ਵਿੱਚ Maven ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਦੇ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕੀਤੀ, ਜਿਸ ਵਿੱਚ .feature ਫਾਈਲ ਵਿੱਚ ਦੱਸੇ ਗਏ ਟੈਸਟ ਕੇਸ ਨੂੰ ਚਲਾਉਣ ਲਈ ਸਾਰੇ ਟੈਸਟਿੰਗ ਦ੍ਰਿਸ਼ ਅਤੇ ਇੱਕ ਰਨਰ ਫਾਈਲ ਸ਼ਾਮਲ ਹੈ।

ਅਨੇਕ ਪੜਾਵਾਂ ਦੇ ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਦੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਰਿਪੋਰਟ ਦੇਖ ਸਕਦੇ ਹਾਂ।

ਸਾਨੂੰ ਉਮੀਦ ਹੈ, ਇਹ ਟਿਊਟੋਰਿਅਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਪਣੀ ਪਹਿਲੀ ਟੈਸਟ ਸਕ੍ਰਿਪਟ ਬਣਾਉਣ ਬਾਰੇ ਸਿੱਖਣ ਵਿੱਚ ਮਦਦਗਾਰ ਸੀ। ਅਤੇ API ਟੈਸਟਿੰਗ ਕਰੋ। ਇਹ ਵਿਸਤ੍ਰਿਤ ਕਦਮ-ਦਰ-ਕਦਮਪਹੁੰਚ API 'ਤੇ ਵੱਖ-ਵੱਖ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਣ ਅਤੇ ਚਲਾਉਣ ਦਾ ਇੱਕ ਸ਼ਾਨਦਾਰ ਤਰੀਕਾ ਹੈ।

ਅੱਗੇ>>

ਲੀ ਨੇ ਇਸ ਨੂੰ ਆਪਣੇ ਖਾਲੀ ਸਮੇਂ ਵਿੱਚ ਵਿਕਸਤ ਕੀਤਾ ਸੀ।

ਹਾਲਾਂਕਿ ਅਸੀਂ ਕਰਾਟੇ ਦੀਆਂ ਦਿਲਚਸਪ ਜੜ੍ਹਾਂ ਨੂੰ ਜਾਣਨਾ ਚਾਹਾਂਗੇ, ਫਿਲਹਾਲ, ਆਓ ਕਰਾਟੇ ਟੂਲ ਬਾਰੇ ਗੱਲ ਕਰੀਏ ਜੋ ਵਿਕਸਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਪੀਟਰ ਥਾਮਸ ਦੁਆਰਾ, API ਟੈਸਟਰਾਂ ਦੇ ਬਚਾਅ ਲਈ ਆਉਣ ਵਾਲੇ ਇੱਕ ਮਹਾਨ ਸਾਧਨਾਂ ਵਿੱਚੋਂ ਇੱਕ।

ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਦੀ ਖੀਰੇ ਦੀ ਸ਼ੈਲੀ ਦਾ ਅਨੁਸਰਣ ਕਰਦਾ ਹੈ ਜੋ BDD ਪਹੁੰਚ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ। ਸੰਟੈਕਸ ਗੈਰ-ਪ੍ਰੋਗਰਾਮਰਾਂ ਦੁਆਰਾ ਸਮਝਣਾ ਆਸਾਨ ਹੈ। ਅਤੇ ਇਹ ਫਰੇਮਵਰਕ ਇਕਮਾਤਰ API ਟੈਸਟਿੰਗ ਟੂਲ ਹੈ ਜਿਸ ਨੇ API ਆਟੋਮੇਸ਼ਨ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਟੈਸਟਿੰਗ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸਟੈਂਡਅਲੋਨ ਟੂਲ ਵਿੱਚ ਜੋੜਿਆ ਹੈ।

ਇਹ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਟੈਸਟ ਕੇਸਾਂ ਨੂੰ ਚਲਾਉਣ ਅਤੇ JSON & XML ਜਾਂਚ।

ਇਸ ਜਾਣਕਾਰੀ ਦੇ ਨਾਲ, ਕਰਾਟੇ ਟੂਲ ਨੂੰ ਵਿਸਥਾਰ ਵਿੱਚ ਸਮਝਣ ਲਈ ਕੁਝ ਮੁੱਖ ਨੁਕਤੇ ਕੱਢੇ ਜਾ ਸਕਦੇ ਹਨ:

  • ਕਰਾਟੇ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ BDD ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਹੈ ਇੱਕ TDD ਦਾ।
  • ਇਸ ਨੂੰ ਗੈਰ-ਪ੍ਰੋਗਰਾਮਰਾਂ ਲਈ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਇੱਕ ਗੇਮ-ਚੇਂਜਰ ਹੈ ਕਿਉਂਕਿ ਇਹ ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਦੁਆਰਾ ਤਕਨੀਕੀ ਪਿਛੋਕੜ ਜਾਂ ਸਮਰੱਥਾ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਵਧੇਰੇ ਵਰਤੋਂ ਅਤੇ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।
  • ਇਹ ਟੈਸਟ ਲਿਖਣ ਲਈ ਖੀਰੇ ਵਿਸ਼ੇਸ਼ਤਾ ਫਾਈਲ ਅਤੇ ਘੇਰਕਿਨਸ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਕਿ ਸਮਝਣ ਵਿੱਚ ਬਹੁਤ ਆਸਾਨ।

ਇਹ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇਸ ਨੂੰ ਅੱਜ ਉਪਲਬਧ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਆਟੋਮੇਸ਼ਨ ਟੂਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਣਾਉਂਦੀਆਂ ਹਨ।

ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਦਾ ਇਤਿਹਾਸ

'ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ 1>ਪੀਟਰ ਥਾਮਸ' 2017 ਵਿੱਚ, ਇਸ ਸੌਫਟਵੇਅਰ ਦਾ ਉਦੇਸ਼ ਟੈਸਟਿੰਗ ਕਰਨਾ ਹੈਕਾਰਜਕੁਸ਼ਲਤਾਵਾਂ ਹਰ ਕਿਸੇ ਲਈ ਆਸਾਨੀ ਨਾਲ ਉਪਲਬਧ ਹਨ। ਇਹ ਜਾਵਾ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਸੀ ਅਤੇ ਜ਼ਿਆਦਾਤਰ ਲੋਕਾਂ ਨੂੰ ਉਮੀਦ ਸੀ ਕਿ ਇਸ ਦੀਆਂ ਫਾਈਲਾਂ ਵੀ ਉਸੇ ਭਾਸ਼ਾ ਵਿੱਚ ਹੋਣਗੀਆਂ, ਹਾਲਾਂਕਿ, ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਅਜਿਹਾ ਨਹੀਂ ਹੈ।

ਇਸ ਦੀ ਬਜਾਏ, ਇਹ ਘੇਰਕਿਨਸ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਇਸਦੇ ਨਾਲ ਇਸ ਦੇ ਸਬੰਧਾਂ ਦਾ ਨਤੀਜਾ ਹੈ। ਖੀਰੇ ਫਰੇਮਵਰਕ. ਆਟੋਮੇਸ਼ਨ ਸੌਫਟਵੇਅਰ ਖੀਰੇ ਦਾ ਇੱਕ ਐਕਸਟੈਂਸ਼ਨ ਹੈ, ਇਸਲਈ ਇਸਦੇ ਸੰਚਾਲਨ ਵਿੱਚ ਘੇਰਕਿਨਸ ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਵਿਰਾਸਤ ਵਿੱਚ ਮਿਲਦੀ ਹੈ। ਦੋਵਾਂ ਵਿੱਚ ਵੱਡਾ ਅੰਤਰ ਇਹ ਹੈ ਕਿ ਕਰਾਟੇ ਟੈਸਟਿੰਗ ਦੌਰਾਨ Java ਦੀ ਕੋਈ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦਾ, ਪਰ ਖੀਰਾ ਕਰਦਾ ਹੈ।

ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਇਹ ਗੈਰ-ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ Gherkins ਸੰਟੈਕਸ ਬਹੁਤ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਵਿਆਪਕ ਹੈ। ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਕਰਾਟੇ ਸਵੈਚਲਿਤ API ਟੈਸਟਿੰਗ ਦੀ ਦੁਨੀਆ ਵਿੱਚ ਦਾਖਲਾ ਲੈਣ ਲਈ ਸਭ ਤੋਂ ਢੁਕਵਾਂ ਅਤੇ ਸਿਫ਼ਾਰਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ।

ਕਰਾਟੇ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਦੀਆਂ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ:

4
  • ਸਮਝਣ ਵਿੱਚ ਆਸਾਨ ਘੇਰਕਿਨਸ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।
  • ਇਸ ਨੂੰ ਜਾਵਾ ਵਰਗੇ ਤਕਨੀਕੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਗਿਆਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
  • ਇਹ ਪ੍ਰਸਿੱਧ ਖੀਰੇ ਦੇ ਮਿਆਰਾਂ 'ਤੇ ਆਧਾਰਿਤ ਹੈ।
  • ਇੱਕ ਫਰੇਮਵਰਕ ਬਣਾਉਣ ਵਿੱਚ ਆਸਾਨ।
  • ਸਮਾਂਤਰ ਟੈਸਟਿੰਗ ਮੁੱਖ ਕਾਰਜਕੁਸ਼ਲਤਾ ਹੈ ਜੋ ਕਿ ਕਰਾਟੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਸ ਲਈ ਸਾਨੂੰ Maven, Gradle , ਆਦਿ 'ਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
  • ਟੈਸਟ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਲਈ UI।
  • ਕਿਸੇ ਹੋਰ ਫਾਈਲ ਤੋਂ ਵਿਸ਼ੇਸ਼ਤਾ ਫਾਈਲ ਨੂੰ ਕਾਲ ਕਰਨਾ।
  • ਡਾਟਾ ਡਰਾਈਵਰ ਟੈਸਟਿੰਗ ਲਈ ਸਮਰਥਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਅੰਦਰ-ਅੰਦਰ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਇਸ ਲਈ ਬਾਹਰੀ ਫਰੇਮਵਰਕ 'ਤੇ ਨਿਰਭਰ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।
  • ਬਿਲਟ-ਇਨ ਨੇਟਿਵ ਰੈਸਟਰਿਪੋਰਟ. ਨਾਲ ਹੀ, ਇਸ ਨੂੰ ਬਿਹਤਰ UI ਰਿਪੋਰਟਾਂ ਅਤੇ ਹੋਰ ਸਪੱਸ਼ਟਤਾ ਲਈ ਖੀਰੇ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।
  • ਵੱਖ-ਵੱਖ ਟੈਸਟਿੰਗ ਵਾਤਾਵਰਣਾਂ (QA, ਪੜਾਅ, ਉਤਪਾਦ, ਪ੍ਰੀ-ਪ੍ਰੋਡ) ਵਿੱਚ ਸੰਰਚਨਾ ਨੂੰ ਬਦਲਣ ਲਈ ਅੰਦਰੂਨੀ ਸਹਾਇਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
  • ਸੀਆਈ/ਸੀਡੀ ਏਕੀਕਰਣ ਲਈ ਸਹਿਜ ਸਮਰਥਨ ਜੋ ਉਪਯੋਗੀ ਹੋ ਸਕਦਾ ਹੈ।
  • ਵੱਖ-ਵੱਖ HTTP ਕਾਲਾਂ ਨੂੰ ਸੰਭਾਲਣ ਦੇ ਸਮਰੱਥ:
    • ਵੈੱਬ ਸਾਕਟ ਸਮਰਥਨ
    • SOAP ਬੇਨਤੀ
    • HTTP
    • ਬ੍ਰਾਊਜ਼ਰ ਕੂਕੀ ਹੈਂਡਲਿੰਗ
    • HTTPS
    • HTML-ਫਾਰਮ ਡੇਟਾ
    • XML ਬੇਨਤੀ

    • ਕਰਾਟੇ ਬਨਾਮ ਰੈਸਟ-ਏਸ਼ਿਓਰਡ ਦੀ ਤੁਲਨਾ

    ਰੈਸਟ ਐਸ਼ਿਓਰਡ : ਇਹ REST ਸੇਵਾਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਜਾਵਾ-ਆਧਾਰਿਤ ਲਾਇਬ੍ਰੇਰੀ ਹੈ। ਇਹ ਕੋਡ ਦੀਆਂ ਲਾਈਨਾਂ ਲਿਖਣ ਲਈ ਜਾਵਾ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ ਕਈ ਬੇਨਤੀ ਸ਼੍ਰੇਣੀਆਂ ਦੀ ਜਾਂਚ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਵੱਖ-ਵੱਖ ਵਪਾਰਕ ਤਰਕ ਸੰਜੋਗਾਂ ਦੀ ਪੁਸ਼ਟੀ ਹੁੰਦੀ ਹੈ।

    ਕਰਾਟੇ ਫਰੇਮਵਰਕ : ਇੱਕ ਖੀਰਾ/ਘੇਰਕਿਨਸ ਆਧਾਰਿਤ ਟੂਲ, ਜੋ ਕਿ SOAP & REST ਸੇਵਾਵਾਂ।

    ਹੇਠ ਦਿੱਤੀ ਸਾਰਣੀ ਵਿੱਚ ਰੈਸਟ-ਏਸ਼ੋਰਡ ਅਤੇ amp; ਵਿਚਕਾਰ ਕੁਝ ਹੋਰ ਪ੍ਰਮੁੱਖ ਅੰਤਰ ਸੂਚੀਬੱਧ ਕੀਤੇ ਗਏ ਹਨ ਕਰਾਟੇ ਫਰੇਮਵਰਕ:

    22 ਅਸੀਂ ਇਸ ਨੂੰ ਬਿਹਤਰ UI ਲਈ Cucumber ਰਿਪੋਰਟਿੰਗ ਪਲੱਗਇਨ ਨਾਲ ਵੀ ਏਕੀਕ੍ਰਿਤ ਕਰ ਸਕਦੇ ਹਾਂ।
    S.No ਬੇਸਿਸ ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਰੈਸਟ-ਏਸ਼ੋਰਡ
    1 ਭਾਸ਼ਾ 23> ਇਹ ਖੀਰੇ ਅਤੇ ਘੇਰਕਿਨਸ ਦੇ ਸੁਮੇਲ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਇਹ ਜਾਵਾ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ
    2 23> ਕੋਡ ਦਾ ਆਕਾਰ ਆਮ ਤੌਰ 'ਤੇ, ਦੀ ਲਾਈਨ ਕੋਡ ਘੱਟ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਖੀਰੇ ਵਰਗੀ ਬਣਤਰ ਦਾ ਅਨੁਸਰਣ ਕਰਦਾ ਹੈ ਕੋਡ ਦੀ ਲਾਈਨ ਵਧੇਰੇ ਹੈ ਕਿਉਂਕਿ ਇਸ ਵਿੱਚਜਾਵਾ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ
    3 ਤਕਨੀਕੀ ਗਿਆਨ ਦੀ ਲੋੜ ਗੈਰ-ਪ੍ਰੋਗਰਾਮਰ ਆਸਾਨੀ ਨਾਲ ਲਿਖ ਸਕਦੇ ਹਨ Gherkins ਕੋਡ ਜਾਵਾ ਕੋਡ ਨੂੰ ਲਿਖਣ ਲਈ ਤਕਨੀਕੀ ਗਿਆਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ
    4 ਡਾਟਾ-ਚਾਲਿਤ ਟੈਸਟਿੰਗ ਉਸੇ ਨੂੰ ਸਮਰਥਨ ਦੇਣ ਲਈ TestNG ਜਾਂ ਇਸਦੇ ਬਰਾਬਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਡਾਟਾ ਟੈਸਟਿੰਗ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ ਇਨ-ਹਾਊਸ ਟੈਗਸ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ
    5 ਕੀ ਇਹ SOAP ਕਾਲ ਸਹਾਇਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਹਾਂ, ਇਹ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਇਹ ਸਿਰਫ ਇੱਕ REST ਬੇਨਤੀ ਨਾਲ ਸਬੰਧਤ ਹੈ
    6 ਪੈਰਲਲ ਟੈਸਟਿੰਗ ਹਾਂ, ਪੈਰਲਲ ਰਿਪੋਰਟ ਬਣਾਉਣ ਦੇ ਨਾਲ ਪੈਰਲਲ ਟੈਸਟਿੰਗ ਆਸਾਨੀ ਨਾਲ ਸਮਰਥਿਤ ਹੈ ਵੀ ਬਹੁਤ ਹੱਦ ਤੱਕ ਨਹੀਂ। ਹਾਲਾਂਕਿ ਲੋਕਾਂ ਨੇ ਅਜਿਹਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਹੈ, ਅਸਫਲਤਾ ਦੀ ਦਰ ਸਫਲਤਾ ਦਰ ਤੋਂ ਵੱਧ ਹੈ
    7 ਰਿਪੋਰਟਿੰਗ ਬਾਹਰੀ ਪਲੱਗਇਨ ਜਿਵੇਂ ਕਿ ਜੂਨਿਟ, ਟੈਸਟਐਨਜੀ
    8 ਉੱਤੇ ਨਿਰਭਰ ਰਹਿਣ ਦੀ ਲੋੜ ਹੈ। 23> ਬਾਹਰੀ ਡੇਟਾ ਲਈ 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) ਇਕਲਿਪਸ

    ਐਕਲਿਪਸ ਇੱਕ ਏਕੀਕ੍ਰਿਤ ਵਿਕਾਸ ਵਾਤਾਵਰਣ ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਖੇਤਰ ਵਿੱਚ. ਇਹ ਜਿਆਦਾਤਰ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਕਰਾਟੇ ਜਾਵਾ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਇਸਲਈ ਇਹ ਵਧੇਰੇ ਅਰਥ ਰੱਖਦਾ ਹੈ ਕਿ ਏਪੀਆਈ ਟੈਸਟ ਸੌਫਟਵੇਅਰ ਲਈ ਈਲੈਪਸ ਗੋ-ਟੂ IDE ਕਿਉਂ ਹੈ। ਇੱਕ ਹੋਰ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਇਹ ਇੱਕ ਓਪਨ-ਸੋਰਸ ਟੂਲ ਹੈ, ਅਤੇ ਇਹ ਇਸ ਟੂਲ ਦੀ ਚੋਣ ਕਰਨ ਦਾ ਇੱਕ ਬਹੁਤ ਮਜ਼ਬੂਤ ​​ਕਾਰਨ ਹੈ।

    ਨੋਟ: ਅਸੀਂ IntelliJ, Visual Studio, ਅਤੇ ਹੋਰ ਵੱਖ-ਵੱਖ ਸੰਪਾਦਕ ਮਾਰਕੀਟ ਵਿੱਚ ਉਪਲਬਧ ਹਨ।

    #2) Maven

    ਇਹ ਇੱਕ ਬਿਲਡ ਆਟੋਮੇਸ਼ਨ ਟੂਲ ਹੈ ਜੋ ਮੁੱਖ ਤੌਰ 'ਤੇ Java ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਕਰਾਟੇ ਵਾਤਾਵਰਨ ਸਥਾਪਤ ਕਰਨ ਅਤੇ ਕੋਡ ਲਿਖਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ। Maven ਦੀਆਂ ਲੋੜਾਂ ਦੇ ਨਾਲ ਆਪਣੇ Eclipse ਨੂੰ ਸੈਟ ਅਪ ਕਰਨ ਲਈ, ਤੁਸੀਂ 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 ਦਾ ਵਿਕਲਪ ਹੈ ਅਤੇ ਬਰਾਬਰ ਸਮਰੱਥਾ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਉਹਨਾਂ ਦੀਆਂ ਸਮਾਨਤਾਵਾਂ ਅਤੇ ਅੰਤਰ ਹਨ ਪਰ ਸਾਡੇ ਕਰਾਟੇ ਕੋਡਾਂ ਲਈ ਇੱਕ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਨ ਵਿੱਚ ਸਮਾਨ ਰੂਪ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

    ਇਸਦੀ ਵਰਤੋਂ ਕਰਨਾ ਆਸਾਨ, ਲਚਕਦਾਰ ਹੈ, ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਕੁਝ ਮਾਡਿਊਲਰਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਪ੍ਰਬੰਧਨ ਲੋੜਾਂ ਹੋਣ। ਪਲੱਗਇਨ ਦਾ ਇੱਕ ਝੁੰਡ। ਗ੍ਰੇਡਲ ਸੈੱਟਅੱਪ ਕੋਡ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ,

    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 ਸੰਮੇਲਨ ਵਿੱਚ ਫਾਈਲਾਂ ਦੇ ਸੰਗਠਨ ਨੂੰ ਵੀ ਬਰਾਬਰ ਦੀ ਇਜਾਜ਼ਤ ਹੈ। ਤੁਸੀਂ ਆਪਣੀਆਂ ਫਾਈਲਾਂ ਨੂੰ Java ਪੈਕੇਜ ਸੰਮੇਲਨਾਂ ਦੇ ਅਨੁਸਾਰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਸੁਤੰਤਰ ਹੋ।

    ਹਾਲਾਂਕਿ, Maven ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼ ਨਿਰਦੇਸ਼ ਦਿੰਦੇ ਹਨ ਕਿ ਗੈਰ-ਜਾਵਾ ਫਾਈਲਾਂ ਦੀ ਸਟੋਰੇਜ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਕੀਤੀ ਜਾਵੇ। ਉਹ ਇੱਕ src/test/resources ਬਣਤਰ ਵਿੱਚ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਅਤੇ ਜਾਵਾ ਫਾਈਲਾਂ ਨੂੰ src/main/java ਦੇ ਅਧੀਨ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।

    ਪਰ ਕਰਾਟੇ ਫਰੇਮਵਰਕ ਦੇ ਨਿਰਮਾਤਾਵਾਂ ਦੇ ਅਨੁਸਾਰ, ਉਹ ਪੱਕਾ ਵਿਸ਼ਵਾਸ ਕਰਦੇ ਹਨ ਕਿ ਅਸੀਂ ਜਾਵਾ ਅਤੇ ਗੈਰ-ਜਾਵਾ ਫਾਈਲਾਂ ਨੂੰ ਨਾਲ ਰੱਖਦੇ ਹਾਂ। ਪਾਸੇ. ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰ, ਇਸ ਨੂੰ ਲੱਭਣਾ ਬਹੁਤ ਸੌਖਾ ਹੈ*.java ਅਤੇ *.feature ਫਾਈਲਾਂ ਜਦੋਂ ਉਹਨਾਂ ਨੂੰ ਸਟੈਂਡਰਡ Maven ਢਾਂਚੇ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਬਜਾਏ ਇਕੱਠੇ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।

    ਇਹ ਤੁਹਾਡੇ pom.xml ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਟਵੀਕ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (Maven ਲਈ): 

        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. ਉਚਿਤ Maven ਮਾਰਗ ਸੈੱਟ ਕਰੋ।
    • JDK & ਜੇ.ਆਰ.ਈ. ਢੁਕਵਾਂ ਮਾਰਗ ਸੈੱਟ ਕਰੋ।

    ਆਓ ਕਦਮ-ਦਰ-ਕਦਮ ਪਹੁੰਚ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ:

    #1) ਇੱਕ ਬਣਾਓ Eclipse Editor ਵਿੱਚ ਨਵਾਂ MAVEN ਪ੍ਰੋਜੈਕਟ

    • ਓਪਨ ਈਲੈਪਸ
    • ਫਾਈਲ 'ਤੇ ਕਲਿੱਕ ਕਰੋ। ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਚੁਣੋ।

    • Maven ਪ੍ਰੋਜੈਕਟ ਚੁਣੋ

    • ਚੁਣੋ ਵਰਕਸਪੇਸ ਟਿਕਾਣਾ।
    • ਆਰਕੀਟਾਈਪ ਚੁਣੋ (ਆਮ ਤੌਰ 'ਤੇ ਅਸੀਂ ਸਧਾਰਨ ਮਾਵੇਨ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ “ Maven-archetype-quickstart 1.1 ” ਚੁਣਦੇ ਹਾਂ)।
    • ਪ੍ਰਦਾਨ ਕਰੋ। ਗਰੁੱਪ ID & ਆਰਟੀਫੈਕਟ ID (ਅਸੀਂ ਆਪਣੀ ਉਦਾਹਰਨ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ)।
      • ਗਰੁੱਪ ਆਈਡੀ : ਕਰਾਟੇ
      • ਆਰਟੀਫੈਕਟ ਆਈਡੀ: ਕਰਾਟੇਟੈਸਟ ਸਕ੍ਰਿਪਟ ਨਮੂਨਾ
    • ਪੂਰਾ ਕਰਨ ਲਈ ਫਿਨਿਸ਼ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਸੈੱਟਅੱਪ।

    #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) ਆਓ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੀਏ, ਅਸੀਂ ਕਿਸ ਵਿੱਚ ਟੈਸਟ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ।

    ਉੱਪਰ ਸਕ੍ਰੋਲ ਕਰੋ