Response body inspection in Postman - Build an Automation Script

Verify response body contains expected user data

Preconditions (2)

Step 1: Send a GET request to https://api.example.com/users/123

Step 2: Inspect the response body

Step 3: Verify the response body contains the user id as 123

Step 4: Verify the response body contains the user name as 'John Doe'

Step 5: Verify the response body contains the user email as '[e-mail]'

✅ Expected Result: The response body should include the correct user id, name, and email as specified

Automation Requirements - Postman Tests (JavaScript)

Assertions Needed:

Response status code is 200

Response body contains user id 123

Response body contains user name 'John Doe'

Response body contains user email '[e-mail]'

Best Practices:

Use pm.response.to.have.status for status code assertion

Parse response body JSON once and reuse

Use strict equality checks for values

Add clear error messages in assertions

Automated Solution

Postman

pm.test('Status code is 200', () => {
    pm.response.to.have.status(200);
});

const responseJson = pm.response.json();

pm.test('User ID is 123', () => {
    pm.expect(responseJson.id, 'User ID').to.eql(123);
});

pm.test('User name is John Doe', () => {
    pm.expect(responseJson.name, 'User name').to.eql('John Doe');
});

pm.test('User email is [e-mail]', () => {
    pm.expect(responseJson.email, 'User email').to.eql('[e-mail]');
});

This script runs inside Postman’s Tests tab after the request is sent.

First, it checks the HTTP status code is 200 to confirm the request succeeded.

Then it parses the response body JSON once and stores it in responseJson for reuse.

Next, it verifies the id, name, and email fields exactly match the expected values using strict equality (to.eql).

Each assertion has a clear label to help identify which check failed if any test does not pass.

Common Mistakes - 4 Pitfalls

Not checking the status code before inspecting the response body

Parsing response body JSON multiple times

Using loose equality (==) instead of strict equality (=== or to.eql)

Not providing descriptive messages in assertions

Bonus Challenge

Now add data-driven testing with 3 different user IDs and verify their respective names and emails

Show Hint

Practice

1. What is the main purpose of inspecting the response body in Postman tests?

easy

A. To verify the server sends the expected data

B. To check the server's response time

C. To validate the request headers

D. To test the network connection speed

Solution

1. Step 1: Understand response body inspection

   Inspecting the response body means looking at the data the server sends back after a request.

2. Step 2: Identify the purpose in testing

   The main goal is to confirm that the server returns the correct and expected data in the response body.

3. Final Answer:

   To verify the server sends the expected data -> Option A

4. Quick Check:

   Response body inspection = Verify expected data [OK]

Hint: Response body check confirms data correctness [OK]

Common Mistakes:

• Confusing response body with response time
• Checking headers instead of body content
• Thinking it tests network speed

2. Which Postman code snippet correctly reads a JSON response body?

easy

A. let data = pm.response.text();

B. let data = pm.request.json();

C. let data = pm.response.json();

D. let data = pm.response.body();

Solution

1. Step 1: Identify method to parse JSON response

   Postman provides pm.response.json() to parse the response body as JSON.

2. Step 2: Check other options for correctness

   pm.response.text() returns plain text, pm.request.json() is invalid for response, pm.response.body() is not a valid method.

3. Final Answer:

   let data = pm.response.json(); -> Option C

4. Quick Check:

   Use pm.response.json() to read JSON [OK]

Hint: Use pm.response.json() to parse JSON body [OK]

Common Mistakes:

• Using pm.response.text() for JSON data
• Trying pm.request.json() which reads request, not response
• Using non-existent pm.response.body() method

3. Given this Postman test code, what will be the test result if the response body is {"status":"success","count":5}?

let jsonData = pm.response.json();
pm.test("Count is 5", function () {
    pm.expect(jsonData.count).to.eql(5);
});

medium

A. Test fails due to syntax error in code

B. Test passes because count equals 5

C. Test fails because count is a string, not number

D. Test passes but count is undefined

Solution

1. Step 1: Parse the JSON response body

   The response body has count as number 5, so jsonData.count is 5.

2. Step 2: Check the assertion

   The test checks if jsonData.count equals 5, which is true, so the test passes.

3. Final Answer:

   Test passes because count equals 5 -> Option B

4. Quick Check:

   jsonData.count = 5, assertion true [OK]

Hint: Match expected value type exactly in assertions [OK]

Common Mistakes:

• Assuming count is string instead of number
• Thinking code has syntax errors
• Ignoring actual response content

4. Identify the error in this Postman test code that checks if the response JSON has a 'user' field:

let data = pm.response.json();
pm.test("User field exists", () => {
    pm.expect(data.user).to.exist();
});

The test always fails even when the response contains 'user'.

medium

A. Using to.exist() instead of to.exist causes failure

B. pm.expect should check data.user !== undefined explicitly

C. Arrow function syntax is incorrect

D. No error; test fails due to missing user field in response

Solution

1. Step 1: Understand Chai syntax for existence check

   In Postman, use pm.expect(value).to.exist; (no parentheses) because 'exist' is a property, not a function.

2. Step 2: Spot the syntax error

   The code has .to.exist(); -- the parentheses treat 'exist' as a function call, causing a TypeError and always failing the test.

3. Step 3: Correct the code

   Remove the parentheses: pm.expect(data.user).to.exist;

4. Final Answer:

   Using to.exist() instead of to.exist causes failure -> Option A

5. Quick Check:

   Use .to.exist without parentheses [OK]

Hint: Use to.exist without parentheses for existence check [OK]

Common Mistakes:

• Adding parentheses to to.exist causing errors
• Misunderstanding arrow function syntax
• Assuming test fails due to missing field

5. You receive this JSON response body:

{
  "users": [
    {"id": 1, "active": true},
    {"id": 2, "active": false},
    {"id": 3, "active": true}
  ]
}

Which Postman test code correctly asserts that all users are active?

hard

A. let data = pm.response.json();
pm.test("All users active", () => {
pm.expect(data.users.length).to.eql(3);
});

B. let data = pm.response.json();
pm.test("All users active", () => {
pm.expect(data.users.some(u => u.active)).to.be.true;
});

C. let data = pm.response.json();
pm.test("All users active", () => {
pm.expect(data.users.filter(u => u.active).length).to.eql(2);
});

D. let data = pm.response.json();
pm.test("All users active", () => {
pm.expect(data.users.every(u => u.active)).to.be.true;
});

Solution

1. Step 1: Understand the requirement

   The test must confirm every user in the array has active: true.

2. Step 2: Analyze each option

   let data = pm.response.json(); pm.test("All users active", () => { pm.expect(data.users.every(u => u.active)).to.be.true; }); uses every() to check all users are active, which is correct.
   let data = pm.response.json(); pm.test("All users active", () => { pm.expect(data.users.some(u => u.active)).to.be.true; }); uses some(), which only checks if at least one user is active.
   let data = pm.response.json(); pm.test("All users active", () => { pm.expect(data.users.filter(u => u.active).length).to.eql(2); }); compares filtered active users count to 2, which checks for exactly 2 active users, not all.
   let data = pm.response.json(); pm.test("All users active", () => { pm.expect(data.users.length).to.eql(3); }); only checks length, not active status.

3. Step 3: Choose the best direct assertion

   let data = pm.response.json(); pm.test("All users active", () => { pm.expect(data.users.every(u => u.active)).to.be.true; }); is the clearest and most direct way to assert all users are active.

4. Final Answer:

   let data = pm.response.json(); pm.test("All users active", () => { pm.expect(data.users.every(u => u.active)).to.be.true; }); -> Option D

5. Quick Check:

   Use every() to assert all items meet condition [OK]

Hint: Use every() to check all array items match condition [OK]

Common Mistakes:

• Using some() which checks only one item
• Checking array length instead of values
• Asserting filter length equals 2 instead of total length