Response body inspection in Postman - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is response body inspection in API testing?

Response body inspection is the process of checking the data returned by an API after a request to ensure it matches expected results.

beginner

How can you view the response body in Postman?

After sending a request in Postman, the response body appears in the lower panel under the Body tab, where you can see the returned data in formats like JSON, XML, or HTML.

beginner

Why is it important to check the response body in API testing?

Checking the response body ensures the API returns correct, complete, and expected data, which helps catch errors and verify functionality.

intermediate

What Postman feature helps automate response body validation?

Postman uses tests written in JavaScript to automatically check if the response body contains expected values or structure.

intermediate

Give an example of a simple Postman test to check if response body contains a key 'status' with value 'success'.

pm.test('Status is success', () => { pm.expect(pm.response.json().status).to.eql('success'); });

Where do you find the response body in Postman after sending a request?

A In the Console tab

B In the Headers tab

C In the Body tab of the response section

D In the Authorization tab

The response body is shown in the Body tab of the response section in Postman.

What is the main purpose of inspecting the response body in API testing?

A To measure response time

B To check if the API returns expected data

C To check the API request headers

D To validate the API URL

Inspecting the response body helps verify that the API returns the correct and expected data.

Which language is used to write tests for response body validation in Postman?

A JavaScript

B Python

C Java

D Ruby

Postman uses JavaScript to write test scripts for validating the response body.

What does this Postman test check? pm.test('Check', () => { pm.expect(pm.response.json().code).to.eql(200); });

A If the response JSON has a 'code' key with value 200

B If the response status code is 200

C If the request URL contains 'code'

D If the response headers include 'code'

The test checks if the JSON response body has a key 'code' with the value 200.

Which format is commonly used for response bodies in APIs and easily inspected in Postman?

A EXE

B CSV

C TXT

D JSON

JSON is the most common format for API response bodies and is well supported in Postman.

Explain how you would inspect and validate the response body of an API using Postman.

Think about the Postman interface and test scripting.

Why is response body inspection crucial in API testing? Give examples of what you might check.

Consider the role of response data in confirming API behavior.

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