Response time assertions in Postman - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ assertion

intermediate

Check if response time is under 500ms

Which Postman test script correctly asserts that the response time is less than 500 milliseconds?

A ;)} ;)005(woleb.eb.ot.)emiTesnopser.esnopser.mp(tcepxe.mp { >= )( ,'sm005 naht ssel si emit esnopseR'(tset.mp

B pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.responseTime).to.be.below(500); });

C pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.responseTime).to.be.above(500); });

D pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.responseTime).to.equal(500); });

💡 Hint

Look for the correct property name and the correct comparison method.

Option B uses the correct property pm.response.responseTime and asserts it is below 500ms, which matches the requirement.

Option B incorrectly checks if response time is above 500ms.

Option B uses a wrong property pm.response.time which does not exist.

Option B checks for equality to 500ms, not less than.

❓ Predict Output

intermediate

Output of response time assertion failure

What will be the test result output if the response time is 600ms for the following Postman test?

pm.test('Response time under 500ms', () => { pm.expect(pm.response.responseTime).to.be.below(500); });

Postman

pm.test('Response time under 500ms', () => { pm.expect(pm.response.responseTime).to.be.below(500); });

A Test fails with syntax error

B Test passes successfully

C Test fails with assertion error: expected 600 to be below 500

D Test is skipped automatically

💡 Hint

Think about what happens when the actual response time is greater than the expected maximum.

The assertion expects the response time to be below 500ms, but the actual is 600ms, so the test fails with an assertion error showing the expected and actual values.

🔧 Debug

advanced

Identify the error in response time assertion script

Find the error in this Postman test script that checks response time:

pm.test('Response time check', () => { pm.expect(response.responseTime).to.be.below(300); });

Postman

pm.test('Response time check', () => { pm.expect(response.responseTime).to.be.below(300); });

A The variable <code>response</code> is undefined; should use <code>pm.response</code>

B The method <code>to.be.below</code> does not exist

C The test name is missing quotes

D The response time should be checked with <code>pm.response.time</code>

💡 Hint

Check the object used to access response properties in Postman scripts.

In Postman test scripts, the response object is accessed via pm.response. Using response alone causes a ReferenceError.

🧠 Conceptual

advanced

Best practice for response time assertion threshold

Which is the best reason to avoid setting a very low response time threshold (e.g., 10ms) in Postman assertions?

A Response time assertions are ignored if threshold is below 50ms

B Lower thresholds improve test accuracy and should always be used

C Postman does not support response time assertions below 100ms

D Network and server variability can cause false test failures even if the API is healthy

💡 Hint

Think about real-world network conditions and server load.

Setting too low a threshold can cause tests to fail due to normal fluctuations in network latency or server processing time, not actual problems.

❓ framework

expert

Implementing a custom response time assertion in Postman

You want to create a Postman test that fails if the response time exceeds 400ms but logs a warning if it is between 300ms and 400ms. Which script correctly implements this behavior?

A pm.test('Response time check', () => { const time = pm.response.responseTime; if (time > 400) { pm.expect.fail(`Response time too high: ${time}ms`); } else if (time > 300) { console.warn(`Warning: Response time is ${time}ms`); } else { pm.expect(time).to.be.below(300); } });

B pm.test('Response time check', () => { const time = pm.response.responseTime; if (time > 400) { console.warn(`Response time too high: ${time}ms`); } else if (time > 300) { pm.expect.fail(`Warning: Response time is ${time}ms`); } else { pm.expect(time).to.be.below(300); } });

C pm.test('Response time check', () => { const time = pm.response.responseTime; if (time > 400) { pm.expect(time).to.be.below(400); } else if (time > 300) { pm.expect(time).to.be.below(300); } });

D pm.test('Response time check', () => { const time = pm.response.responseTime; if (time > 300) { pm.expect.fail(`Response time too high: ${time}ms`); } else { pm.expect(time).to.be.below(400); } });

💡 Hint

Consider how to fail a test explicitly and how to log warnings without failing.

Option A correctly fails the test if time > 400ms using pm.expect.fail(), logs a warning if time is between 300ms and 400ms using console.warn, and passes otherwise.

Option A reverses fail and warn logic.

Option A does not log warnings and does not fail explicitly.

Option A fails for times above 300ms, which is stricter than required.

Practice

1. What does pm.response.responseTime represent in Postman tests?

easy

A. The size of the API response in bytes

B. The number of API requests sent

C. The HTTP status code of the response

D. The time taken by the API to respond in milliseconds

Solution

1. Step 1: Understand the property pm.response.responseTime

   This property in Postman returns the time taken by the API server to send a response, measured in milliseconds.

2. Step 2: Differentiate from other response properties

   It does not represent response size, status code, or request count, which are different properties.

3. Final Answer:

   The time taken by the API to respond in milliseconds -> Option D

4. Quick Check:

   Response time = API speed [OK]

Hint: Response time means how fast API replies in ms [OK]

Common Mistakes:

• Confusing response time with response size
• Mixing response time with HTTP status code
• Thinking it counts number of requests

2. Which of the following is the correct syntax to assert that response time is less than 500 milliseconds in Postman test script?

easy

A. pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.time).to.be.above(500); });

B. pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.responseTime).to.be.below(500); });

C. pm.test('Response time is less than 500ms', () => { pm.expect(responseTime).to.equal(500); });

D. pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.responseTime).to.be.above(500); });

Solution

1. Step 1: Identify correct property and assertion method

   The correct property for response time is pm.response.responseTime. To check if it is less than 500ms, use to.be.below(500).

2. Step 2: Verify syntax correctness

   pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.responseTime).to.be.below(500); }); uses the correct property and assertion syntax. Other options use wrong properties or wrong comparison methods.

3. Final Answer:

   pm.test('Response time is less than 500ms', () => { pm.expect(pm.response.responseTime).to.be.below(500); }); -> Option B

4. Quick Check:

   Use pm.response.responseTime with to.be.below() [OK]

Hint: Use pm.response.responseTime with to.be.below() for less than checks [OK]

Common Mistakes:

• Using wrong property like pm.response.time
• Using to.be.above() instead of to.be.below()
• Missing pm.expect wrapper

3. Given the following Postman test code, what will be the test result if the API response time is 450 ms?

pm.test('Response time is acceptable', () => {
  pm.expect(pm.response.responseTime).to.be.below(400);
});

medium

A. Test will pass because 450 is below 400

B. Test will pass because 450 equals 400

C. Test will fail because 450 is not below 400

D. Test will error due to syntax mistake

Solution

1. Step 1: Understand the assertion condition

   The test expects pm.response.responseTime to be below 400 milliseconds.

2. Step 2: Compare actual response time with condition

   The actual response time is 450 ms, which is greater than 400 ms, so the condition fails.

3. Final Answer:

   Test will fail because 450 is not below 400 -> Option C

4. Quick Check:

   450 > 400 means test fails [OK]

Hint: Check if actual time is less than threshold to pass [OK]

Common Mistakes:

• Assuming 450 is below 400
• Confusing pass/fail logic
• Ignoring comparison operator meaning

4. Identify the error in this Postman test script for response time assertion:

pm.test('Response time check', function() {
  pm.expect(pm.response.responseTime).to.be.lessThan(300);
});

medium

A. The assertion method lessThan is incorrect in Postman tests

B. The function syntax is invalid

C. The property pm.response.responseTime does not exist

D. The test name is missing

Solution

1. Step 1: Check assertion method correctness

   Postman uses Chai assertion library where the correct method to check less than is to.be.below(), not lessThan().

2. Step 2: Verify other parts of the script

   The function syntax is valid, the property exists, and the test name is present.

3. Final Answer:

   The assertion method lessThan is incorrect in Postman tests -> Option A

4. Quick Check:

   Use to.be.below() not lessThan() [OK]

Hint: Use to.be.below() for less than, not lessThan() [OK]

Common Mistakes:

• Using lessThan() instead of to.be.below()
• Thinking lessThan() is valid Chai syntax
• Ignoring assertion library conventions

5. You want to write a Postman test that fails if the response time is more than 1000 ms but passes if it is exactly 1000 ms or less. Which assertion code correctly implements this logic?

hard

A. pm.test('Response time check', () => { pm.expect(pm.response.responseTime).to.be.at.most(1000); });

B. pm.test('Response time check', () => { pm.expect(pm.response.responseTime).to.be.below(1000); });

C. pm.test('Response time check', () => { pm.expect(pm.response.responseTime).to.equal(1000); });

D. pm.test('Response time check', () => { pm.expect(pm.response.responseTime).to.be.above(1000); });

Solution

1. Step 1: Understand the requirement

   The test should pass if response time is 1000 ms or less, and fail if more than 1000 ms.

2. Step 2: Choose correct assertion method

   to.be.at.most(1000) checks if value is less than or equal to 1000, matching the requirement. to.be.below(1000) excludes 1000, to.equal(1000) only passes exactly 1000, and to.be.above(1000) is opposite.

3. Final Answer:

   pm.test('Response time check', () => { pm.expect(pm.response.responseTime).to.be.at.most(1000); }); -> Option A

4. Quick Check:

   Use to.be.at.most() for <= checks [OK]

Hint: Use to.be.at.most() for less than or equal assertions [OK]

Common Mistakes:

• Using to.be.below() excludes equal value
• Using to.equal() only matches exact value
• Using to.be.above() reverses logic