Response body inspection in Postman - Test Execution Trace

Test Overview

This test sends a GET request to a sample API endpoint and verifies that the response body contains the expected user data in JSON format.

Test Code - Postman

Postman

pm.test("Response body contains user data", function () {
    pm.response.to.have.status(200);
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('user');
    pm.expect(jsonData.user).to.have.property('id').that.is.a('number');
    pm.expect(jsonData.user).to.have.property('name').that.is.a('string');
});

Execution Trace - 6 Steps

Step	Action	System State	Assertion	Result
1	Send GET request to https://api.example.com/user/123	Request sent, waiting for response	—	PASS
2	Receive response with status 200 and JSON body	Response body: {"user":{"id":123,"name":"Alice"}}	Check response status is 200	PASS
3	Parse response body as JSON	Parsed JSON object available	—	PASS
4	Verify response JSON has property 'user'	JSON contains 'user' object	Assert jsonData has property 'user'	PASS
5	Verify 'user' object has numeric 'id'	'user.id' is 123	Assert user.id is a number	PASS
6	Verify 'user' object has string 'name'	'user.name' is 'Alice'	Assert user.name is a string	PASS

Failure Scenario

Failing Condition: Response body does not contain 'user' property or 'user.id' is not a number

Execution Trace Quiz - 3 Questions

What does the test check first after receiving the response?

A That the response body is empty

B That the response body contains 'name'

C That the response status is 200

D That the response time is less than 1 second

Key Result

Always verify the response status code before inspecting the response body to ensure the API call was successful.

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