Response body inspection in Postman

Introduction

Response body inspection helps you check if the server sends the right data after a request. It ensures your app gets what it expects.

After sending an API request to verify the returned data is correct.

When testing if error messages appear properly in the response.

To confirm that the response format matches the API specification.

When debugging why your app shows wrong or missing information.

To check if sensitive data is not exposed in the response body.

Syntax

Postman

pm.test("Test name", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.key).to.eql("expected value");
});

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

Assertions check if the response data matches what you expect.

Examples

This test checks if the response has a name field equal to "Alice".

Postman

pm.test("Check user name", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.name).to.eql("Alice");
});

This test confirms the status field says "success".

Postman

pm.test("Verify status is success", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.status).to.eql("success");
});

This test checks if an error field exists in the response.

Postman

pm.test("Response has error message", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.error).to.exist;
});

Sample Program

This test checks that the response body contains a user object with the correct id and email.

Postman

pm.test("Verify user ID and email", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.user.id).to.eql(123);
    pm.expect(jsonData.user.email).to.eql("[e-mail]");
});

Important Notes

Always parse the response body before checking its content.

Use clear test names to understand what each test checks.

Check for both existence and exact values to avoid false positives.

Summary

Response body inspection confirms the server sends expected data.

Use pm.response.json() to read JSON responses.

Write clear tests to check specific fields and values.

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