Default and conditional responses in Postman - Build an Automation Script

Verify default and conditional responses in Postman API request

Preconditions (3)

Step 1: Open Postman and create a new GET request to https://api.example.com/data

Step 2: Send the request without any query parameters

Step 3: Verify the response status code is 200

Step 4: Verify the response body contains JSON data with a default message

Step 5: Send the request with query parameter type=json

Step 6: Verify the response status code is 200

Step 7: Verify the response body contains JSON data matching the 'json' type format

Step 8: Send the request with query parameter type=xml

Step 9: Verify the response status code is 200

Step 10: Verify the response body contains XML data matching the 'xml' type format

✅ Expected Result: The API returns a default JSON response when no type parameter is provided. When type=json is sent, the response is JSON formatted data. When type=xml is sent, the response is XML formatted data. All responses have status code 200.

Automation Requirements - Postman test scripts (JavaScript)

Assertions Needed:

Response status code is 200

Response body contains expected default JSON message when no type parameter

Response body is valid JSON and matches expected structure when type=json

Response body is valid XML and matches expected structure when type=xml

Best Practices:

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

Use pm.expect with JSON.parse for JSON validation

Use xml2Json library for XML validation

Write separate tests for each request variation

Use descriptive test names

Avoid hardcoding entire response bodies; check key fields

Automated Solution

Postman

/* Test script for default response (no query parameter) */
pm.test('Status code is 200', () => {
    pm.response.to.have.status(200);
});

pm.test('Response has default JSON message', () => {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('message');
    pm.expect(jsonData.message).to.eql('Default response');
});

/* Test script for type=json */
// Run this script after sending request with ?type=json
pm.test('Status code is 200', () => {
    pm.response.to.have.status(200);
});

pm.test('Response is valid JSON with expected structure', () => {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('data');
    pm.expect(jsonData.data).to.be.an('array');
});

/* Test script for type=xml */
// Run this script after sending request with ?type=xml
const xml2Json = require('xml2json');
pm.test('Status code is 200', () => {
    pm.response.to.have.status(200);
});

pm.test('Response is valid XML with expected root element', () => {
    const xmlData = pm.response.text();
    let jsonObj;
    try {
        jsonObj = JSON.parse(xml2Json.toJson(xmlData));
    } catch (e) {
        pm.expect.fail('Response is not valid XML');
    }
    pm.expect(jsonObj).to.have.property('response');
});

This Postman test script is divided into three parts for each request variation.

First, it checks the default response when no query parameter is sent. It asserts the status code is 200 and the JSON response contains a 'message' property with value 'Default response'.

Second, for the request with ?type=json, it asserts the status code and verifies the response JSON has a 'data' property which is an array, indicating the expected JSON structure.

Third, for the request with ?type=xml, it asserts the status code and uses the xml2json library to convert XML response text to JSON. It then checks that the converted JSON has a 'response' root element, confirming valid XML structure.

Each test uses Postman's pm API for assertions and parsing. This approach keeps tests clear, focused, and maintainable.

Common Mistakes - 4 Pitfalls

Not checking the status code before parsing the response

Hardcoding entire response body in assertions

Not validating XML responses properly

Using the same test script for all request variations without separation

Bonus Challenge

Now add data-driven testing with 3 different 'type' parameter values: none, 'json', and 'xml' in a single Postman collection test.

Show Hint

Practice

1. What is the main purpose of using default and conditional responses in Postman tests?

easy

A. To send multiple requests at the same time

B. To change the API endpoint dynamically

C. To check different API responses in one test script

D. To automatically generate API documentation

Solution

1. Step 1: Understand the role of conditional responses

   Conditional responses allow testing different API replies based on conditions in one place.

2. Step 2: Identify the main purpose

   This helps verify various outcomes without writing separate tests for each response.

3. Final Answer:

   To check different API responses in one test script -> Option C

4. Quick Check:

   Default and conditional responses = test multiple replies [OK]

Hint: Think: one test script, many response checks [OK]

Common Mistakes:

• Confusing response testing with sending requests
• Assuming it changes API endpoints
• Mixing testing with documentation generation

2. Which of the following is the correct syntax to write a conditional test in Postman to check if the response status is 200?

easy

A. pm.test('Status is 200', () => { if (pm.response.code === 200) { pm.expect(true).to.be.true; } });

B. pm.test('Status is 200', () => { pm.expect(pm.response.code).to.equal(200); });

C. pm.test('Status is 200', () => pm.response.code == 200);

D. pm.test('Status is 200', () => { if (pm.response.status == 200) pm.expect(true); });

Solution

1. Step 1: Review Postman test syntax

   Postman uses pm.test with a callback function and pm.expect for assertions.

2. Step 2: Identify correct assertion for status code

   pm.expect(pm.response.code).to.equal(200) correctly asserts status code equals 200.

3. Final Answer:

   pm.test('Status is 200', () => { pm.expect(pm.response.code).to.equal(200); }); -> Option B

4. Quick Check:

   pm.expect with .to.equal(200) = correct syntax [OK]

Hint: Use pm.expect with .to.equal for exact value checks [OK]

Common Mistakes:

• Using '==' instead of .to.equal() in assertions
• Checking pm.response.status instead of pm.response.code
• Not calling pm.expect properly inside pm.test

3. Given this Postman test code, what will be the test result if the response status is 404?

pm.test('Check response', () => {
  if (pm.response.code === 200) {
    pm.expect(pm.response.json().success).to.be.true;
  } else {
    pm.expect(pm.response.code).to.equal(404);
  }
});

medium

A. Test passes because status is 404 and matches else condition

B. Test fails because success property is missing

C. Test throws an error due to missing JSON body

D. Test passes only if success is true

Solution

1. Step 1: Analyze the if-else condition with status 404

   Status 404 triggers the else block which asserts pm.response.code equals 404.

2. Step 2: Check assertion in else block

   pm.expect(pm.response.code).to.equal(404) will pass since status is 404.

3. Final Answer:

   Test passes because status is 404 and matches else condition -> Option A

4. Quick Check:

   404 status triggers else assertion = pass [OK]

Hint: Match status code to correct if/else branch [OK]

Common Mistakes:

• Assuming test fails due to missing success property
• Thinking JSON parsing fails on 404
• Ignoring else block assertions

4. Identify the error in this Postman test script that checks for a 201 status or a 400 error:

pm.test('Status check', () => {
  if (pm.response.code = 201) {
    pm.expect(pm.response.code).to.equal(201);
  } else if (pm.response.code = 400) {
    pm.expect(pm.response.json().error).to.exist;
  }
});

medium

A. No else block to handle other status codes

B. Missing pm.expect in the first if block

C. Incorrect JSON parsing method

D. Using assignment '=' instead of comparison '===' in if conditions

Solution

1. Step 1: Check if condition syntax

   The code uses '=' which assigns value instead of '===' for comparison.

2. Step 2: Understand impact of assignment in conditions

   Assignment always returns true, causing logic errors and wrong test behavior.

3. Final Answer:

   Using assignment '=' instead of comparison '===' in if conditions -> Option D

4. Quick Check:

   Use '===' for comparisons, not '=' [OK]

Hint: Use '===' for comparisons, '=' is assignment [OK]

Common Mistakes:

• Confusing '=' with '==' or '==='
• Ignoring that assignment returns a value
• Not validating all possible status codes

5. You want to write a Postman test that checks if the response status is 200 and the JSON body has a 'data' field, but if the status is 404, it should check for an 'error' message. Which code snippet correctly implements this conditional response test?

hard

A. pm.test('Conditional response test', () => {
if (pm.response.code === 200) {
pm.expect(pm.response.json().data).to.exist;
} else if (pm.response.code === 404) {
pm.expect(pm.response.json().error).to.exist;
} else {
pm.expect.fail('Unexpected status code');
}
});

B. pm.test('Conditional response test', () => {
pm.expect(pm.response.code === 200 && pm.response.json().data).to.exist;
pm.expect(pm.response.code === 404 && pm.response.json().error).to.exist;
});

C. pm.test('Conditional response test', () => {
if (pm.response.code = 200) {
pm.expect(pm.response.json().data).to.exist;
} else if (pm.response.code = 404) {
pm.expect(pm.response.json().error).to.exist;
}
});

D. pm.test('Conditional response test', () => {
pm.expect(pm.response.json().data || pm.response.json().error).to.exist;
});

Solution

1. Step 1: Check correct use of comparison operators

   pm.test('Conditional response test', () => { if (pm.response.code === 200) { pm.expect(pm.response.json().data).to.exist; } else if (pm.response.code === 404) { pm.expect(pm.response.json().error).to.exist; } else { pm.expect.fail('Unexpected status code'); } }); uses '===' for comparisons correctly. Using '=' causes assignment instead of comparison.

2. Step 2: Verify conditional logic and assertions

   The code checks 'data' field existence for status 200, 'error' for 404, and explicitly fails for unexpected codes using pm.expect.fail().

3. Step 3: Evaluate other options

   One option incorrectly combines status and field checks in single pm.expect statements, causing failures. Another does not condition on status codes at all.

4. Final Answer:

   pm.test('Conditional response test', () => { if (pm.response.code === 200) { pm.expect(pm.response.json().data).to.exist; } else if (pm.response.code === 404) { pm.expect(pm.response.json().error).to.exist; } else { pm.expect.fail('Unexpected status code'); } }); -> Option A

5. Quick Check:

   Use if-else with '===' and proper assertions [OK]

Hint: Use if-else with '===' and separate assertions [OK]

Common Mistakes:

• Using '=' instead of '===' in conditions
• Combining conditions inside one pm.expect
• Not handling unexpected status codes