Response body assertions in Postman - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ assertion

intermediate

Check if response JSON contains a specific key with expected value

Given a JSON response body, which Postman test script correctly asserts that the key status has the value success?

Postman

pm.test('Status is success', function () {
    // Write assertion here
});

A pm.expect(pm.response.json().status).to.eql('success');

B pm.expect(pm.response.json().status).to.be.true();

C pm.expect(pm.response.json().status).to.equal(true);

D pm.expect(pm.response.json().status).to.be('success');

💡 Hint

Use the correct assertion method to compare values exactly.

Option A uses to.eql() which checks deep equality and matches the string 'success'. Other options either use wrong assertion methods or compare to wrong types.

❓ assertion

intermediate

Verify response body contains a non-empty array

Which Postman test script correctly asserts that the response JSON has a key items which is an array with at least one element?

Postman

pm.test('Items array is not empty', function () {
    // Write assertion here
});

A pm.expect(pm.response.json().items).to.be.an('array').that.is.not.empty;

B pm.expect(pm.response.json().items).to.have.lengthOf.above(0);

C pm.expect(pm.response.json().items.length).to.be.above(0);

D pm.expect(pm.response.json().items).to.have.length.above(0);

💡 Hint

Use chaining to check type and emptiness.

Option A correctly asserts that items is an array and is not empty using Chai's BDD style. Other options have syntax errors or incorrect chaining.

❓ Predict Output

advanced

Output of response body assertion with nested JSON

What will be the result of this Postman test script if the response body is {"user":{"id":123,"active":true}}?

Postman

pm.test('User is active', function () {
    pm.expect(pm.response.json().user.active).to.be.false;
});

A Test passes because active is true

B Test fails with assertion error because active is true, not false

C SyntaxError due to incorrect assertion method

D Test fails with TypeError because user key is missing

💡 Hint

Check the actual value of the active key and the assertion used.

The assertion expects active to be false but the response has it as true, so the test fails with an assertion error.

🔧 Debug

advanced

Identify the error in response body assertion script

What is wrong with this Postman test script if the response body is {"data":{"count":5}}?

pm.test('Count is 5', function () {
    pm.expect(pm.response.json().count).to.eql(5);
});

A Test will pass because count equals 5

B SyntaxError due to missing semicolon

C Assertion method to.eql() is invalid

D pm.response.json().count is undefined because count is nested inside data

💡 Hint

Check the JSON path used to access the count key.

The script tries to access count at the root level but it is inside the data object, so pm.response.json().count is undefined causing the assertion to fail.

🧠 Conceptual

expert

Best practice for asserting optional keys in response body

In Postman tests, what is the best way to assert that an optional key message in the response body is either absent or a non-empty string if present?

A Fail the test if <code>message</code> key is missing

B Always assert <code>message</code> is a non-empty string without checking existence

C Use a conditional check: if <code>message</code> exists, assert it is a non-empty string; else pass the test

D Ignore the <code>message</code> key entirely in tests

💡 Hint

Think about how to handle keys that may or may not be present.

Option C is best practice because it handles both cases gracefully: if the key exists, it validates the value; if not, it does not fail the test unnecessarily.

Practice

1. What does pm.response.json() do in Postman tests?

easy

A. It parses the response body as a JSON object.

B. It sends a new request to the server.

C. It clears the response body.

D. It validates the response status code.

Solution

1. Step 1: Understand the purpose of pm.response.json()

   This function reads the response body and converts it into a JSON object for easy access.

2. Step 2: Compare with other options

   Sending requests, clearing body, or validating status are different functions, not pm.response.json().

3. Final Answer:

   It parses the response body as a JSON object. -> Option A

4. Quick Check:

   Parsing response body = A [OK]

Hint: Remember: json() reads response body as JSON [OK]

Common Mistakes:

• Confusing json() with sending requests
• Thinking json() clears data
• Mixing response body parsing with status code checks

2. Which of the following is the correct syntax to assert that the response JSON has a key status with value success in Postman?

easy

A. pm.expect(response.status).to.equal('success');

B. pm.response.json().status == 'success';

C. pm.expect(pm.response.json().status).to.eql('success');

D. pm.assert(pm.response.status == 'success');

Solution

1. Step 1: Identify correct assertion syntax in Postman

   Postman uses pm.expect() with Chai assertion style, so pm.expect(pm.response.json().status).to.eql('success'); is correct.

2. Step 2: Check other options for errors

   pm.response.json().status == 'success'; lacks assertion, C uses wrong object, D uses incorrect method.

3. Final Answer:

   pm.expect(pm.response.json().status).to.eql('success'); -> Option C

4. Quick Check:

   Use pm.expect() with to.eql() for value check [OK]

Hint: Use pm.expect() with to.eql() for JSON value checks [OK]

Common Mistakes:

• Using == instead of pm.expect() for assertions
• Referencing response.status instead of response.json().status
• Using pm.assert() which is not a Postman function

3. Given this response body:

{"user":{"id":5,"name":"Alice"}}

What will this test output?

const jsonData = pm.response.json();
pm.test("User ID is 5", () => {
  pm.expect(jsonData.user.id).to.equal(5);
});

medium

A. Test passes because user.id equals 5.

B. Test fails because user.id is not 5.

C. Test throws an error due to syntax.

D. Test is skipped because no assertion is made.

Solution

1. Step 1: Parse the response JSON

   The response has user.id = 5, so jsonData.user.id is 5.

2. Step 2: Evaluate the assertion

   The test asserts jsonData.user.id equals 5, which is true, so the test passes.

3. Final Answer:

   Test passes because user.id equals 5. -> Option A

4. Quick Check:

   Value matches assertion = Pass [OK]

Hint: Match JSON path value with expected to pass test [OK]

Common Mistakes:

• Misreading JSON structure
• Assuming test fails without checking value
• Confusing syntax errors with assertion failures

4. Identify the error in this Postman test code:

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

medium

A. Missing semicolon after assertion line.

B. No error; the test code is correct.

C. Incorrect function name; should be pm.test, not pm.tests.

D. Missing parentheses after pm.expect.

Solution

1. Step 1: Review syntax of Postman test code

   The code uses pm.test correctly, with proper arrow function and assertion syntax.

2. Step 2: Check for syntax errors

   Semicolons are optional in JavaScript; parentheses and function names are correct.

3. Final Answer:

   No error; the test code is correct. -> Option B

4. Quick Check:

   Correct syntax means no error [OK]

Hint: Check function names and parentheses carefully [OK]

Common Mistakes:

• Confusing pm.test with pm.tests
• Thinking semicolons are mandatory
• Missing parentheses in pm.expect

5. You want to assert that the response JSON array items contains an object with id equal to 10. Which test code correctly checks this in Postman?

hard

A. pm.expect(pm.response.json().items.id).to.equal(10);

B. const items = pm.response.json().items;
pm.expect(items.find(id => id === 10)).to.exist;

C. pm.expect(pm.response.json().items.includes({id:10})).to.be.true;

D. const items = pm.response.json().items;
pm.expect(items.some(item => item.id === 10)).to.be.true;

Solution

1. Step 1: Understand the response structure

   items is an array of objects; we want to check if any object has id 10.

2. Step 2: Evaluate each option

   const items = pm.response.json().items; pm.expect(items.some(item => item.id === 10)).to.be.true; uses some() to check if any item has id === 10, which is correct. pm.expect(pm.response.json().items.id).to.equal(10); wrongly accesses items.id (invalid). pm.expect(pm.response.json().items.includes({id:10})).to.be.true; tries to use includes() with an object, which won't work. const items = pm.response.json().items; pm.expect(items.find(id => id === 10)).to.exist; uses find() but the callback is incorrect (should check item.id).

3. Final Answer:

   const items = pm.response.json().items; pm.expect(items.some(item => item.id === 10)).to.be.true; -> Option D

4. Quick Check:

   Use some() with correct callback for array check [OK]

Hint: Use some() to check if array contains object with property [OK]

Common Mistakes:

• Using includes() with objects (doesn't work)
• Accessing array properties directly
• Incorrect callback function in find()