Why Tests tab and pm.test() in Postman? - Purpose & Use Cases

The Big Idea

What if you never had to guess if your API worked right after sending a request?

The Scenario

Imagine you manually check each API response by reading through long JSON data every time you send a request in Postman.

You try to remember if the status code was 200 or if the response had the right fields.

The Problem

This manual checking is slow and tiring.

You can easily miss errors or forget to check important details.

It's hard to keep track of what passed or failed after many requests.

The Solution

The Tests tab with pm.test() lets you write small checks that run automatically after each request.

It quickly tells you if your API works as expected, saving time and avoiding mistakes.

Before vs After

✗ Before

Send request -> Read response -> Remember if status is 200 -> Check fields manually

✓ After

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

What It Enables

You can instantly see which API tests pass or fail, making your testing faster and more reliable.

Real Life Example

When testing a login API, pm.test() can automatically check if the response contains a token and a success message every time you send the request.

Key Takeaways

Manual checking is slow and error-prone.

pm.test() automates response checks in Postman.

This makes API testing faster, clearer, and less stressful.

Practice

1. What is the main purpose of the pm.test() function in Postman's Tests tab?

easy

A. To define a named test and run assertions on the API response

B. To send an API request to the server

C. To format the API response data

D. To create a new collection in Postman

Solution

1. Step 1: Understand the role of pm.test()

   The pm.test() function is used to define a test with a descriptive name and a function that contains checks or assertions.

2. Step 2: Identify what pm.test() does in the Tests tab

   It runs the test function to verify if the API response meets expected conditions, helping automate validation.

3. Final Answer:

   To define a named test and run assertions on the API response -> Option A

4. Quick Check:

   pm.test() defines tests = A [OK]

Hint: pm.test() names and runs checks on responses [OK]

Common Mistakes:

• Confusing pm.test() with sending requests
• Thinking pm.test() formats data
• Assuming pm.test() creates collections

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

easy

A. pm.test('Status code is 200', function { pm.response.status == 200 });

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

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

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

Solution

1. Step 1: Review correct pm.test() syntax

   The correct syntax uses a test name string and a function with assertions inside, like an arrow function.

2. Step 2: Check assertion method for status code

   Using pm.response.to.have.status(200) is the proper way to assert status code 200.

3. Final Answer:

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

4. Quick Check:

   Correct syntax uses arrow function and .to.have.status() [OK]

Hint: Use arrow function and .to.have.status() for status checks [OK]

Common Mistakes:

• Passing boolean instead of function to pm.test()
• Using assignment '=' instead of comparison '=='
• Omitting parentheses in function declaration

3. Consider this test code in Postman:

pm.test('Response has userId 1', () => {
  const jsonData = pm.response.json();
  pm.expect(jsonData.userId).to.eql(1);
});

What will happen if the API response JSON is {"userId": 2}?

medium

A. The test will fail because userId is not 1

B. The test will pass because userId exists

C. The test will throw a syntax error

D. The test will be skipped automatically

Solution

1. Step 1: Understand the test assertion

   The test checks if jsonData.userId equals 1 using pm.expect().to.eql(1).

2. Step 2: Compare actual response value

   The response has userId as 2, which does not equal 1, so the assertion fails.

3. Final Answer:

   The test will fail because userId is not 1 -> Option A

4. Quick Check:

   Assertion fails if values differ = B [OK]

Hint: pm.expect() fails if actual ≠ expected [OK]

Common Mistakes:

• Assuming test passes if key exists
• Confusing eql() with assignment
• Thinking test skips on mismatch

4. You wrote this test in Postman:

pm.test('Check response time', () => {
  pm.expect(pm.response.responseTime).to.be.below(200);
});

But the test always fails even when response time is below 200ms. What is the likely error?

medium

A. The property pm.response.responseTime is correct, but the test function is missing parentheses

B. Incorrect property name; should be pm.response.response_time

C. The property pm.response.responseTime is correct, but the test fails if responseTime is undefined or not a number

D. Using to.be.below instead of to.be.lessThan

Solution

1. Step 1: Verify property name and assertion

   pm.response.responseTime is the correct property for response time in milliseconds, and to.be.below() is valid syntax.

2. Step 2: Consider why test fails despite correct syntax

   If responseTime is undefined or not a number, the assertion will fail even if the actual response time is low.

3. Final Answer:

   The property pm.response.responseTime is correct, but the test fails if responseTime is undefined or not a number -> Option C

4. Quick Check:

   Undefined or wrong type causes assertion failure = A [OK]

Hint: Check property exists and is number before asserting [OK]

Common Mistakes:

• Assuming wrong assertion method causes failure
• Using incorrect property names
• Missing parentheses in arrow function

5. You want to write a Postman test that checks if the response JSON contains a non-empty array called items and that each item has a price greater than 0. Which test code correctly implements this?

hard

A. pm.test('Items array and prices', () => {
const jsonData = pm.response.json();
pm.expect(Array.isArray(jsonData.items)).to.be.true;
pm.expect(jsonData.items.length).to.be.above(0);
jsonData.items.forEach(item => pm.expect(item.price).to.be.above(0));
});

B. pm.test('Items array and prices', () => {
const jsonData = pm.response.json();
pm.expect(jsonData.items).to.be.an('array').and.not.empty;
pm.expect(jsonData.items.every(item => item.price > 0)).to.be.true;
});

C. pm.test('Items array and prices', () => {
const jsonData = pm.response.json();
pm.expect(jsonData.items).to.exist;
pm.expect(jsonData.items.length > 0);
jsonData.items.forEach(item => pm.expect(item.price > 0));
});

D. pm.test('Items array and prices', () => {
const jsonData = pm.response.json();
pm.expect(jsonData.items).to.be.an('array');
pm.expect(jsonData.items.length).to.be.greaterThan(0);
jsonData.items.forEach(item => pm.expect(item.price).to.be.greaterThan(0));
});

Solution

1. Step 1: Check array existence and length

   pm.test('Items array and prices', () => { const jsonData = pm.response.json(); pm.expect(jsonData.items).to.be.an('array'); pm.expect(jsonData.items.length).to.be.greaterThan(0); jsonData.items.forEach(item => pm.expect(item.price).to.be.greaterThan(0)); }); correctly uses pm.expect(jsonData.items).to.be.an('array') and to.be.greaterThan(0) to verify the array is non-empty.

2. Step 2: Verify each item's price check

   pm.test('Items array and prices', () => { const jsonData = pm.response.json(); pm.expect(jsonData.items).to.be.an('array'); pm.expect(jsonData.items.length).to.be.greaterThan(0); jsonData.items.forEach(item => pm.expect(item.price).to.be.greaterThan(0)); }); uses pm.expect(item.price).to.be.greaterThan(0) inside a forEach loop, which is valid and clear.

3. Step 3: Compare with other options

   Options A and B use slightly different syntax but A uses to.be.above(0) which is valid but less common than to.be.greaterThan(0). B uses every() which is valid but chaining to.be.an('array').and.not.empty is not standard Chai syntax in Postman. C has incorrect assertions missing function calls.

4. Final Answer:

   Option D correctly implements all checks with valid syntax -> Option D

5. Quick Check:

   Use .to.be.an('array') and .to.be.greaterThan() for checks [OK]

Hint: Use .to.be.an('array') and .to.be.greaterThan() for clear checks [OK]

Common Mistakes:

• Using incorrect assertion chaining syntax
• Missing function calls in pm.expect()
• Not checking array length before iterating