Why advanced tests handle complex scenarios in Postman - Automation Benefits in Action

Verify API handles complex user creation scenarios

Preconditions (3)

Step 1: Open Postman and create a new POST request to the user creation API endpoint

Step 2: In the request body, enter a JSON payload with valid username, email, password, multiple roles, and nested metadata

Step 3: Send the request

Step 4: Verify the response status code is 201 Created

Step 5: Verify the response body contains the created user's id and matches the sent data

Step 6: Repeat the request with missing required fields and verify the API returns 400 Bad Request with appropriate error messages

Step 7: Repeat the request with invalid email format and verify the API returns 422 Unprocessable Entity

Step 8: Repeat the request with duplicate username and verify the API returns 409 Conflict

✅ Expected Result: The API correctly handles complex user creation scenarios by returning appropriate status codes and response bodies for valid and invalid inputs.

Automation Requirements - Postman test scripts

Assertions Needed:

Response status code is as expected (201, 400, 422, 409)

Response body contains expected fields and error messages

Response data matches the request data for successful creation

Best Practices:

Use Postman test scripts with pm.expect assertions

Validate both positive and negative scenarios

Use descriptive test names and comments

Avoid hardcoding values; use variables where appropriate

Automated Solution

Postman

pm.test('Status code is 201 for valid user creation', () => {
    pm.response.to.have.status(201);
});

const responseJson = pm.response.json();
pm.test('Response contains user id', () => {
    pm.expect(responseJson).to.have.property('id');
});

pm.test('Response username matches request', () => {
    const requestJson = pm.request.body.raw ? JSON.parse(pm.request.body.raw) : {};
    pm.expect(responseJson.username).to.eql(requestJson.username);
});

// Negative test for missing fields
if(pm.response.code === 400) {
    pm.test('Response has error message for missing fields', () => {
        pm.expect(responseJson).to.have.property('error');
        pm.expect(responseJson.error).to.include('missing');
    });
}

// Negative test for invalid email
if(pm.response.code === 422) {
    pm.test('Response has error message for invalid email', () => {
        pm.expect(responseJson).to.have.property('error');
        pm.expect(responseJson.error).to.include('email');
    });
}

// Negative test for duplicate username
if(pm.response.code === 409) {
    pm.test('Response has error message for duplicate username', () => {
        pm.expect(responseJson).to.have.property('error');
        pm.expect(responseJson.error).to.include('duplicate');
    });
}

This Postman test script checks the API response after sending a user creation request.

First, it verifies the status code is 201 for a successful creation.

Then it checks the response JSON contains a user id and that the username matches the request data.

For negative scenarios, it uses conditional checks on the status code to verify appropriate error messages for missing fields (400), invalid email (422), and duplicate username (409).

This approach ensures the API handles complex scenarios correctly by validating both success and error responses.

Common Mistakes - 3 Pitfalls

Not checking the response status code before validating the body

Hardcoding values directly in test scripts without using variables

Testing only positive scenarios and ignoring error cases

Bonus Challenge

Now add data-driven testing with 3 different user payloads including valid, missing fields, and invalid email

Show Hint

Practice

1. Why do advanced tests in Postman handle complex scenarios?

easy

A. To avoid using JavaScript in tests

B. To make tests run faster by skipping details

C. To check software behavior in real-life tricky situations

D. To reduce the number of assertions used

Solution

1. Step 1: Understand the purpose of advanced tests

   Advanced tests are designed to simulate real-life complex situations to ensure software behaves correctly.

2. Step 2: Analyze the options

   Only To check software behavior in real-life tricky situations correctly states that advanced tests check tricky real-life scenarios. Other options contradict the purpose of advanced tests.

3. Final Answer:

   To check software behavior in real-life tricky situations -> Option C

4. Quick Check:

   Advanced tests = check complex scenarios [OK]

Hint: Advanced tests simulate real situations to find hidden bugs [OK]

Common Mistakes:

• Thinking advanced tests reduce assertions
• Believing advanced tests skip details
• Assuming JavaScript is not used in Postman tests

2. Which of the following is the correct syntax to write an assertion in Postman test script?

easy

A. pm.test('Check status', function { pm.response.status(200); });

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

C. pm.assert('Status 200', pm.response.status == 200);

D. pm.check('Status code', () => pm.response.status(200));

Solution

1. Step 1: Review Postman test syntax

   Postman uses pm.test with a description and a function containing assertions using pm.response.to.have.status.

2. Step 2: Compare options to correct syntax

   pm.test('Status code is 200', () => { pm.response.to.have.status(200); }); matches the correct syntax. Options B, C, and D use incorrect function syntax or non-existent methods.

3. Final Answer:

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

4. Quick Check:

   pm.test + arrow function + pm.response.to.have.status = correct [OK]

Hint: Use pm.test with arrow function and pm.response.to.have.status [OK]

Common Mistakes:

• Using function keyword without parentheses
• Using pm.assert or pm.check which don't exist
• Missing arrow function syntax

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

pm.test('Status is 200', () => {
  pm.response.to.have.status(200);
});
pm.test('Response has userId', () => {
  const jsonData = pm.response.json();
  pm.expect(jsonData).to.have.property('userId');
});

medium

A. First test fails, second test may error or fail

B. Both tests pass

C. First test passes, second test fails

D. Both tests fail silently

Solution

1. Step 1: Analyze first test with status 404

   The first test expects status 200 but response is 404, so it fails.

2. Step 2: Analyze second test accessing JSON property

   If response body is not JSON or missing 'userId', pm.response.json() may throw error or test fails due to missing property.

3. Final Answer:

   First test fails, second test may error or fail -> Option A

4. Quick Check:

   Status 404 breaks status test and risks JSON test failure [OK]

Hint: Check status first; wrong status can cause later test errors [OK]

Common Mistakes:

• Assuming tests pass regardless of status
• Ignoring possible JSON parse errors
• Thinking tests fail silently without error

4. Identify the error in this Postman test script and fix it:

pm.test('Check user name', () => {
  const data = pm.response.json;
  pm.expect(data.name).to.eql('Alice');
});

medium

A. Use single quotes around 'Alice' instead of double quotes

B. Replace pm.expect with pm.assert

C. Remove arrow function and use regular function syntax

D. Change pm.response.json to pm.response.json()

Solution

1. Step 1: Identify the error in accessing JSON

   pm.response.json is a function and must be called with parentheses to get parsed JSON.

2. Step 2: Correct the code by adding parentheses

   Change pm.response.json to pm.response.json() to correctly parse response body.

3. Final Answer:

   Change pm.response.json to pm.response.json() -> Option D

4. Quick Check:

   Call pm.response.json() as a function to parse JSON [OK]

Hint: Always call pm.response.json() with parentheses [OK]

Common Mistakes:

• Forgetting parentheses on pm.response.json
• Using pm.assert instead of pm.expect
• Changing quotes unnecessarily

5. You want to write an advanced Postman test that checks if the response JSON array contains at least one object with "status" equal to "active" and "age" greater than 30. Which test script correctly handles this complex scenario?

hard

A. pm.test('Check active user over 30', () => {
const users = pm.response.json();
const found = users.some(u => u.status === 'active' && u.age > 30);
pm.expect(found).to.be.true;
});

B. pm.test('Check active user over 30', () => {
const users = pm.response.json();
pm.expect(users.status).to.eql('active');
pm.expect(users.age).to.be.above(30);
});

C. pm.test('Check active user over 30', () => {
const users = pm.response.json();
for (let i = 0; i < users.length; i++) {
pm.expect(users[i].status === 'active' && users[i].age > 30).to.be.true;
}
});

D. pm.test('Check active user over 30', () => {
const users = pm.response.json();
pm.expect(users.filter(u => u.status === 'active')).to.have.length.above(0);
});

Solution

1. Step 1: Understand the requirement

   We need to check if at least one user has status 'active' and age > 30.

2. Step 2: Evaluate each option's logic

   pm.test('Check active user over 30', () => { const users = pm.response.json(); const found = users.some(u => u.status === 'active' && u.age > 30); pm.expect(found).to.be.true; }); uses Array.some() to find if any user meets both conditions, then asserts true. pm.test('Check active user over 30', () => { const users = pm.response.json(); pm.expect(users.status).to.eql('active'); pm.expect(users.age).to.be.above(30); }); wrongly checks properties on the whole array. pm.test('Check active user over 30', () => { const users = pm.response.json(); for (let i = 0; i < users.length; i++) { pm.expect(users[i].status === 'active' && users[i].age > 30).to.be.true; } }); asserts every user meets condition, which is too strict. pm.test('Check active user over 30', () => { const users = pm.response.json(); pm.expect(users.filter(u => u.status === 'active')).to.have.length.above(0); }); only checks status but ignores age condition.

3. Final Answer:

   pm.test('Check active user over 30', () => { const users = pm.response.json(); const found = users.some(u => u.status === 'active' && u.age > 30); pm.expect(found).to.be.true; }); -> Option A

4. Quick Check:

   Use some() to check any matching object [OK]

Hint: Use Array.some() to test if any item meets all conditions [OK]

Common Mistakes:

• Checking properties on entire array instead of items
• Testing all items instead of any item
• Ignoring one of the conditions