Skip to content
Postman API Testing Tips

How To Use Tests In Postman

API Testing Blog

Mastering API Testing with Postman Tests

Postman, a popular API platform, offers powerful testing capabilities that go beyond simply sending requests. By writing tests within Postman, you can automate validation of your API responses, ensuring consistency, accuracy, and reliability. This guide will equip you with the knowledge to write effective Postman tests, covering various test types and best practices.

1. Understanding Postman Tests

Postman tests are written using JavaScript and are executed after each request. The pm object provides an array of functions to interact with the response and make assertions about expected behavior. Before we dive into writing tests, let’s understand the fundamental concepts:

  • Test Scripts: JavaScript code snippets within the “Tests” tab of a request or collection.
  • Assertions: Using pm.test() to verify specific conditions within the response data.
  • Response Data Access: The pm.response object provides methods to access different parts of the response like pm.response.json(), pm.response.text(), pm.response.headers, etc.

2. Getting Started with Basic Postman Tests

Let’s walk through a simple example to illustrate the core principles:

2.1 Scenario: Testing a GET Request for User Data

Step 1: Create a GET Request:

  • In Postman, create a GET request to your API endpoint, e.g., https://api.example.com/users/123.

Step 2: Write a Basic Test:

  • Go to the “Tests” tab within the request.
  • Add the following code:
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

Explanation:

  • pm.test(): This function defines a test case.
  • "Status code is 200": This is a descriptive name for your test.
  • pm.response.to.have.status(200): This assertion checks if the response status code is 200 (OK).

Step 3: Run the Test:

  • Send the GET request.
  • The test will be executed automatically, and the result will be displayed in the “Tests” tab.

2.2 Verifying Response Data

Scenario: Checking if the user name is “John Doe” in the response:

pm.test("User name is John Doe", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.name).to.eql("John Doe");
});

Explanation:

  • pm.response.json(): Retrieves the response body as JSON data.
  • pm.expect(jsonData.name).to.eql("John Doe"): This assertion checks if the name property in the JSON response matches “John Doe”.

3. Advanced Postman Testing Techniques

Postman offers various powerful features to enhance your testing workflows:

3.1 Parameterization and Data-Driven Testing

Scenario: Testing different user IDs in a loop:

var userIds = [123, 456, 789];


userIds.forEach(function (userId) {
    pm.test("User ID: " + userId + " has a valid status code", function () {
        pm.sendRequest({
            url: "https://api.example.com/users/" + userId,
            method: "GET"
        }, function (err, response) {
            if (err) {
                console.log(err);
            } else {
                pm.expect(response.code).to.be.within(200, 299);
            }
        });
    });
});

Explanation:

  • pm.sendRequest(): This function allows sending requests within the test script, enabling dynamic testing.
  • userIds.forEach(): This loop iterates through an array of user IDs, sending individual requests.
  • pm.expect(response.code).to.be.within(200, 299): Verifies if the response code is within the range of 200-299, indicating successful requests.

3.2 Environment Variables and Data Storage

Scenario: Using environment variables to store API keys:

  • Set up a Postman environment with an API key variable (e.g., API_KEY).
  • Replace hardcoded values in your requests with the environment variable.
pm.test("API key is valid", function () {
    pm.expect(pm.environment.get("API_KEY")).to.not.be.empty;
});

Explanation:

  • pm.environment.get("API_KEY"): This function retrieves the value of the “API_KEY” environment variable.
  • pm.expect(...).to.not.be.empty: Asserts if the variable value is not empty.

3.3 Custom Test Functions

Scenario: Defining a reusable function to check response time:

function checkResponseTime(threshold) {
    pm.test("Response time below " + threshold + "ms", function () {
        pm.expect(pm.response.responseTime).to.be.below(threshold);
    });
}


checkResponseTime(500); // call the custom function with a threshold

Explanation:

  • checkResponseTime(threshold): This reusable function accepts a threshold value as input and checks if the response time is below that threshold.

4. Utilizing Postman Collections

Postman collections provide a way to organize your requests and tests into groups. They are crucial for building comprehensive test suites:

4.1 Creating Test Suites with Collections

  • Create a Collection: Organize your API requests within a logical collection.
  • Add Tests to Requests: Write individual tests for each request within the collection.
  • Run Collections: Run all tests in the collection with a single button click.

4.2 Test Suites in the “Tests” Tab of a Collection

Collections also feature a “Tests” tab, allowing you to write tests that run once, before all requests in the collection begin. This is perfect for setting up preconditions like authentication or initializing variables.

pm.test("API is reachable", function () {
    pm.sendRequest({
        url: "https://api.example.com/",
        method: "GET"
    }, function (err, response) {
        if (err) {
            console.log(err);
        } else {
            pm.expect(response.code).to.be.within(200, 299);
        }
    });
});

5. Best Practices for Postman Testing

  • Clear and Descriptive Test Names: Use meaningful names for your tests to easily understand their purpose.
  • Modular Tests: Break down tests into smaller, reusable functions for better organization and maintainability.
  • Error Handling: Implement try-catch blocks to handle unexpected errors and gracefully exit tests.
  • Test Coverage: Aim for comprehensive test coverage, testing various scenarios and edge cases.
  • Version Control: Store your Postman collections in version control to track changes and collaborate with others.

Postman’s robust testing framework offers a powerful way to ensure the quality of your APIs. By using these techniques and best practices, you can create comprehensive test suites that increase your confidence in API deployments.

API Testing Blog