Why running collections validates flows in Postman - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does running a Postman collection validate API flows?

When you run a Postman collection, what is the main reason it helps validate the API flows?

A It generates random data to test the API without following the defined flow.

B It only checks the syntax of the API endpoints without sending any requests.

C It executes all requests in sequence, checking if each response meets expected conditions, ensuring the flow works end-to-end.

D It runs only one request from the collection to test the API's speed.

💡 Hint

Think about what happens when you run multiple requests in order and check their results.

Running a collection sends each request in order and verifies responses. This confirms that the API behaves correctly through the entire flow, not just individual calls.

❓ Predict Output

intermediate

What is the test result after running this Postman test script?

Consider this Postman test script inside a request in a collection:

pm.test('Status code is 200', () => {
    pm.response.to.have.status(200);
});
pm.test('Response has userId', () => {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('userId');
});

If the API response is {"userId": 5, "name": "Alice"} with status 200, what will be the test result?

A Both tests pass, so the collection run continues successfully.

B The first test fails because status is not 200.

C The second test fails because 'userId' is missing.

D Both tests fail due to syntax errors in the script.

💡 Hint

Check the status code and presence of 'userId' in the response.

The response status is 200, so the first test passes. The response JSON has 'userId', so the second test also passes. Both tests succeed.

❓ assertion

advanced

Which assertion correctly verifies the response time is under 500ms in Postman?

You want to add a test in Postman to check that the API response time is less than 500 milliseconds. Which assertion is correct?

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

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

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

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

💡 Hint

Look for the property that holds response time and the correct comparison method.

pm.response.responseTime holds the response time in milliseconds. Using to.be.below(500) correctly asserts it is less than 500ms.

🔧 Debug

advanced

Why does this Postman test script fail during collection run?

Look at this test script inside a Postman request:

pm.test('Check user name', () => {
    const data = pm.response.json();
    pm.expect(data.name).to.eql('John');
});

The API response is {"name": null}. What is the reason the test fails?

A The test fails because the test syntax is incorrect; missing semicolon.

B The test fails because the response 'name' is null, not 'John'.

C The test fails because pm.expect is not defined in Postman.

D The test fails because pm.response.json() throws a syntax error.

💡 Hint

Compare the expected value with the actual response value.

The test expects 'name' to be 'John', but the response has 'name' as null, so the assertion fails.

❓ framework

expert

What is the main benefit of running a Postman collection with environment variables for flow validation?

When running a Postman collection that tests a user registration and login flow, why is it important to use environment variables to store data like userId or authToken?

A It allows sharing data between requests dynamically, so later requests can use values from earlier responses to validate the full flow.

B It automatically encrypts all API requests for security during the collection run.

C It disables all tests except the first request to speed up the collection run.

D It generates random user data for each request without needing to parse responses.

💡 Hint

Think about how data from one request can be used in the next during a flow.

Environment variables let you save values from one request (like userId) and reuse them in later requests, enabling the collection to validate the entire flow dynamically.