The Most Comprehensive ‘How to use’ Postman Guide for 2024

Data Parametrization to make Postman Tests Reusable

Request parameterisation in Postman allows you to define variables that can be used across multiple requests. This is particularly useful for testing different scenarios or for reusing similar requests with different data. We'll continue using the JSONPlaceholder API for this example.

Step-by-Step Guide for Request Parameterisation in Postman

1. Setting Up Environment Variables

1.1. Create an Environment: First, you need to create an environment in Postman. Click on the “Environments” tab on the left sidebar. Click on “New” to create a new environment. Name it something relevant, like “TestEnv”.

1.2. Add Variables: In your new environment, add variables that you want to parameterise. For example, you can create variables like baseUrl and userId. Set the initial value for baseUrl as https://jsonplaceholder.typicode.com and for userId as 1.

1.3. Select the Environment: Once you've set up your environment, select it from the dropdown at the top right corner of Postman.

2. Using Variables in Requests

2.1. Create a GET Request: Let’s say you want to fetch posts of a specific user. Create a new request by clicking on the "+" tab.

2.2. Set Up the GET Request with Variables: In the URL field, use the variables by wrapping them in double curly braces. For example, enter {{baseUrl}}/posts?userId={{userId}}. This tells Postman to replace these placeholders with the corresponding variable values from the selected environment.

2.3. Send the Request: Click “Send” and observe how Postman substitutes the variables with their actual values and executes the request.

3. Changing Variable Values

1. Edit Variables: Go back to your environment settings. Change the value of userId to another number, like 2.

   
   

2. Resend the Request: With the environment still selected, resend the same request. Notice how the request now fetches posts for the updated user ID.

   
   

4. Using Variables in POST Request

1. Create a POST Request: Open a new tab and set the request type to POST. For the URL, use {{baseUrl}}/posts.

   
   

2. Setup Headers: Set the “Content-Type” header to “application/json”.

   
   

3. Setup Body with Variables: In the request body (raw JSON format), you can also use variables. For example:

{
  "title": "A Title",
  "body": "Post body",
  "userId": {{userId}}
}

Postman can also generate random data for your requests without the need for you to prepare a dataset yourself. This is typically done using dynamic variables in Postman's scripting feature. Postman has a built-in dynamic variable feature and scripting capabilities in the Pre-request Script and Tests sections, where you can use JavaScript to generate random data.

➡️Using Built-in Dynamic Variables

Postman offers a set of dynamic variables that you can use directly in your requests. For example:

• {{$randomInt}}: A random integer between 0 and 1000.

• {{$guid}}: A v4 style GUID.

• {{$timestamp}}: The current UNIX timestamp.

• {{$randomFirstName}}: A random first name.

  
  

You can use these directly in your URL, query parameters, headers, or body. For example, if you need a random email, you could set up your JSON body like this:

{
"email": "user{{$randomInt}}@example.com",
"name": "{{$randomFirstName}}"
}

➡️Using Pre-request Scripts for Custom Random Data

For more specific random data needs, you can write JavaScript code in the Pre-request Script tab of your request. Here's an example:

javascriptCopy code
// Generate a random user ID between 1 and 100
pm.environment.set("userId", Math.floor(Math.random() * 100) + 1);

// Generate a random username
var usernames = ['userA', 'userB', 'userC', 'userD'];
pm.environment.set("userName", usernames[Math.floor(Math.random() * usernames.length)]);

Then, in your request, you can use {{userId}} and {{userName}} as variables, and they will be replaced with the values set in the script.

Creating test data for data-driven testing is widely recognized as a significant challenge by QA professionals. HyperTest's mocking capabilities entirely remove the difficulty of maintaining states for testing specific features. Let's shed some light on this:

Imagine you’re testing an e-commerce app. There’s this new feature of “loyalty points” you want to test.

But before getting to that stage, you need to prepare several pieces of test data, including:

➡️A valid user account

➡️A valid product listing

➡️Sufficient inventory for the product

➡️The addition of the product to a shopping cart

This setup is necessary before the app reaches the state where the discount via loyalty points can be applied.

The scenario described is relatively straightforward. However, an e-commerce app may contain hundreds of such flows requiring test data preparation. Managing the test data and app states for numerous scenarios significantly increases the workload and stress for QA engineers.

HyperTest has developed an approach to help quality teams test end-to-end scenarios without needing to spend any time creating and managing test data.

Interested in data driven testing without needing data preparation?

➡️Using Tests to Assert Random Responses

Similarly, if you want to validate the response of a request that returns random data, you can write scripts in the Tests tab. For example, to check if a returned ID is an integer:

javascriptCopy code
var jsonData = pm.response.json();
pm.test("ID is an integer", function () {
    pm.expect(Number.isInteger(jsonData.id)).to.be.true;
});

Postman Collections

A Postman Collection is a group of saved API requests that can be organized into folders. Collections are useful for grouping together related API requests, which can be for the same API or a set of APIs that serve a similar function. Collections in Postman can also contain subfolders, environments, tests, and scripts, providing a comprehensive suite for API testing and development.

1. Creating the Collection

• Start by Creating a New Collection: In Postman, click on the “New” button, then choose “Collection”. Name the collection, for example, “JSONPlaceholder API Tests”.

  
  

• Add Descriptions (Optional): You can add a description to your collection, which can include notes about the API, its usage, or any other relevant information.

2. Adding Requests to the Collection

• Create Requests for Various Endpoints: Within this collection, you can create different API requests corresponding to the various endpoints of the JSONPlaceholder API. For example:

  
  

  • A GET request to /posts to retrieve all posts.

  • A POST request to /posts to create a new post.

  • A GET request to /posts/{id} to retrieve a specific post by ID.

  • A PUT request to /posts/{id} to update a specific post.

  • A DELETE request to /posts/{id} to delete a specific post.

    
    

• Organizing with Folders: For better organization, you can create folders within the collection. For instance, separate folders for “Posts”, “Comments”, “Users”, etc., if you plan to expand testing to cover these areas.

3. Adding Tests and Scripts

• Each request in the collection can have its own set of tests and pre-request scripts. This allows you to automate testing and set up environments dynamically. For instance, you might write tests to validate the response structure and status code for each GET request.

  
  

4. Using Environments with the Collection

• You can create and select different environments for your collection. For example, you might have a “Testing” environment with the base URL set to the JSONPlaceholder API. This environment can then be used across all requests in the collection.

  
  

5. Sharing and Collaboration

• Collections can be shared with team members or exported for use by other stakeholders. This is particularly useful for collaborative projects and ensures consistency across different development environments.

  
  

6. Running Collections

• Postman also allows you to run the entire collection or specific folders within a collection. This is useful for regression testing, where you need to verify that your API behaves as expected after changes.

Interested in an approach that can automatically generate Postman collections without writing scripts?

Data Driven Testing

Now that you understand Postman collections, you’d be interested in a Postman capability that lets you test your APIs with different data sets. This helps you verify if the APIs in a test scenarios behave the same way with different data without manually changing the input for each test.

Example: Data-Driven Testing with JSONPlaceholder API

Scenario: Testing User Posts Creation

Suppose you want to test the creation of posts for different users and ensure that the API correctly processes various input data. You would need to test the POST request to the /posts endpoint with different sets of user data.

Step 1: Prepare the Data File

First, you need to create a data file in JSON or CSV format. This file should contain the data sets you want to test. Here's an example JSON data file:

[
{"userId": 1, "title": "Post 1", "body": "Body of post 1"},
{"userId": 2, "title": "Post 2", "body": "Body of post 2"},
{"userId": 3, "title": "Post 3", "body": "Body of post 3"}
]

Each object in the array represents a different set of data to be used in the test.

Step 2: Create a POST Request in Postman

Create a new request in Postman to POST data to https://jsonplaceholder.typicode.com/posts.

In the request body, use variables to represent data that will be taken from your data file. For example:

{
"userId": {{userId}},
"title": "{{title}}",
"body": "{{body}}"
}

Step 3: Write Tests for Your Request

In the "Tests" tab of the request, you can write tests to validate the response for each data set. For example:

pm.test("Response has correct userId", function () {
var responseJson = pm.response.json();
pm.expect(responseJson.userId).to.eql(parseInt(pm.variables.get("userId")));
});

This test checks if the userId in the response matches the userId sent in the request.

Step 4: Running the Collection with the Data File

• Save your request into a collection.

• To run the collection with your data file, click on the Runner button in Postman.

• Drag and drop your collection into the Runner, and then drag and drop your data file into the "Select File" area under the "Data" section.

• Run the collection. Postman will execute the request once for each set of data in your data file.

Step 5: Analyze the Test Results

• In the Runner, you'll see the results of each test for every iteration (each set of data from your file).

• Review the results to ensure your API handles each data set as expected.

Mocking: Powerful way to simulate and test APIs

Mocking is a trick that is routinely employed by developers and testers to continue to test APIs that depend on external services or 3rd party APIs, without needing these dependencies available all the time. Say you are developer that needs to test a new feature and in order to do that successfully you call and consume the response of any external, 3rd party or internal API.

Mocking allows you to keep a dummy response of the dependency ready as when you run a collection or Postman test that runs your API. This also helps when you want to test interactions with APIs that you don't control or when you're trying to avoid costs, rate limits, or side effects of using the real API.

Example Scenario: Mocking a Weather API

Scenario Description

Suppose your application needs to fetch weather information from a third-party weather API. The actual API, let's call it RealWeatherAPI, provides weather data based on location. However, you want to mock this API for testing purposes.

Step 1: Define the API Request

1. Identify the API Request: Determine the structure of the request you need to make. For example, a GET request to https://realweatherapi.com/data?location=London to fetch weather data for London.

   
   

Step 2: Create a Mock Request in Postman

1. Open Postman and create a new request.

2. Set Up the Request: Use the method and URL pattern of the RealWeatherAPI. For example, set the method to GET and URL to something like https://{{mockServer}}/data?location=London.

   
   

Step 3: Define a Sample Response

1. Add a New Example: In the request setup, go to the "Examples" section and create a new example.

2. Mock the Response:

   • Set the response status to 200 OK.

   • Define a mock response body that resembles what you'd expect from RealWeatherAPI. For example:

   
   

{
"location": "London",
"temperature": "15°C",
"condition": "Partly Cloudy"
}

Step 4: Create a Mock Server

1. Navigate to the 'Mocks' Tab and create a new mock server.

2. Configure the Mock Server:

   • Choose the request you created.

   • Give your mock server a name, like "Weather API Mock".

   • Create the mock server and copy its URL.

Step 5: Use the Mock Server

1. Update the Request URL: Replace {{mockServer}} in your request URL with the actual mock server URL provided by Postman.

2. Send the Request: When you send the request, you should receive the mocked response you defined earlier.

   
   

Step 6: Integrate Mock Server in Your Application

1. Use the Mock Server URL: In your application code, replace calls to RealWeatherAPI with calls to your Postman mock server.

2. Test Your Application: Test your application's functionality using the mock responses to ensure it handles the data correctly.

Interested in testing with mocks without having to write and maintain mocks?

Conclusion

We conclude the article here, having focused specifically on topics that are relevant for beginner to intermediate level developers and API testers who want to consider Postman for API development, management and testing.

Postman stands out not just as a tool for making API calls, but as a complete suite for API development, testing, documentation, and collaboration. Its ability to simulate various scenarios, automate tests, and integrate seamlessly into different stages of API lifecycle management makes it an indispensable asset for developers and testers alike.

If you've reached this point and appreciate Postman's capabilities, take a look at HyperTest. It effortlessly manages tasks, automatically crafting and executing API tests, conducting data-driven testing without any data preparation, and handling advanced features like API mocking and environment management. The no-code capability of our solution has empowered teams at companies such as Nykaa, Fyers, Porter, etc., leading to a remarkable 50% reduction in testing time and a substantial 90% enhancement in code quality.

See it in action now!