Skip to content
Postman API Testing Tips

How To Use Postman For Node Js

API Testing Blog

Harnessing the Power of Postman for Node.js: A Comprehensive Guide

Postman, a powerful tool for API testing, seamlessly integrates with Node.js to expedite your development workflow. This guide delves into the essentials of utilizing Postman for Node.js, equipping you with the knowledge to test your APIs effectively.

1. Setting Up the Environment

Before diving into API testing, ensure your environment is properly configured:

1. Install Node.js: Download and install the appropriate Node.js version from the official website (https://nodejs.org/). This package incorporates npm, the Node Package Manager, which is crucial for managing project dependencies.

2. Install Postman: Obtain the Postman app from its official website (https://www.postman.com/downloads/). Postman is available for various operating systems, catering to your preferred workflow.

3. Create a Node.js Project: Create a new directory for your Node.js project. Initialize it using npm:

Terminal window
mkdir my-api-project
cd my-api-project
npm init -y

This command generates a package.json file, which serves as a manifest for your project dependencies and metadata.

2. Creating a Simple Node.js API

Let’s begin by creating a basic Node.js API to practice with.

1. Create a server.js file:

const express = require('express');
const app = express();
const port = 3000;


app.get('/hello', (req, res) => {
  res.send('Hello from Node.js!');
});


app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
});

This code sets up a basic Express.js server that listens on port 3000. It defines a GET endpoint /hello which upon request returns the message ‘Hello from Node.js!‘.

2. Start the server:

Terminal window
node server.js

Now, your server is running, and you’re ready to test it with Postman!

3. Testing Your API with Postman

1. Open Postman: Launch the Postman application and create a new request.

2. Configure the Request:

  • Method: Select GET from the dropdown menu.
  • URL: Enter the URL of your endpoint: http://localhost:3000/hello
  • Headers: You can add headers to your request if needed. For this example, we’ll leave it empty.

3. Send the Request: Click the “Send” button to execute the request.

4. Inspect the Response: Postman displays the response from your server. Verify the response code (200 - OK) and the expected message “Hello from Node.js!” within the body of the response.

Congratulations! You’ve successfully tested your Node.js API using Postman.

4. Sending Data with Postman

Let’s enhance our API to accept and process data.

1. Modify your server.js file:

const express = require('express');
const app = express();
const port = 3000;


app.post('/users', (req, res) => {
  const user = req.body;
  res.send(`User created: ${JSON.stringify(user)}`);
});


app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
});

This modification defines a POST endpoint /users that expects a JSON payload containing user details. 2. Utilize Postman for Sending Data:

  • Method: Choose POST.
  • URL: http://localhost:3000/users
  • Headers: Add a header: Content-Type: application/json
  • Body: Select the “Raw” tab and paste the following JSON data:
{
  "name": "John Doe",
  "email": "john.doe@example.com",
  "age": 30
}
  • Send the Request: Click “Send”.

3. Inspect the Response: Examine the response. You should see the status code 200 and a message similar to: User created: {"name":"John Doe","email":"john.doe@example.com","age":30}

5. Testing with Environment Variables and Collections

1. Environment Variables: Use Postman’s environment variables to manage different API endpoints based on development, testing, or production environments.

  • Create an Environment: Navigate to the “Environments” tab in Postman and create a new environment. You can name it dev, test, or prod for example.
  • Add Variables: Within your environment, add variables to store endpoint URLs:
   {
    "id": "dev",
    "values": [
      {
        "key": "apiUrl",
        "value": "http://localhost:3000",
        "type": "text",
        "enabled": true
      }
    ]
   }
  • Use the variable in your request: Update the URL in your Postman request to {{apiUrl}}/hello to dynamically fetch the environment-specific URL.

2. Postman Collections Organize your API requests efficiently with collections.

  • Create a New Collection: Go to the “Collections” tab and click “Create Collection” to create a new collection. Name it logically, for example, “My API Tests”.
  • Add Requests: Add the requests you’ve defined (GET /hello and POST /users) to your collection.
  • Run the Collection: Execute all requests within the collection sequentially by clicking the “Run” button.

6. Handling Authentication and Authorization

API testing frequently involves authentication and authorization mechanisms. Postman empowers you to manage this easily:

1. Basic Authentication:

  • Add Authorization: Select the “Authorization” tab in your request and choose “Basic Auth”.
  • Enter Credentials: Provide the username and password for your API.

2. OAuth 2.0:

  • Configure OAuth: Utilize the “OAuth 2.0” option in the “Authorization” tab. Provide the necessary details like client ID, client secret, authorization URL, and token URL based on your API’s authentication system.
  • Obtain Access Token: Postman will guide you through the OAuth 2.0 flow to obtain an access token.
  • Add Access Token to Request: Once the access token is acquired, it will be added to your request automatically.

7. Advanced Testing with Postman

Postman offers advanced features to enrich your API testing experience:

1. Test Scripting: Postman’s scripting functionality allows you to write JavaScript code to validate responses, handle logic, and customize requests.

pm.test("Status code is 200", function () {
  pm.response.to.have.status(200);
});


pm.test("Response body contains 'Hello'", function () {
  pm.expect(pm.response.text()).to.include('Hello');
});

2. Mocking: Create mock servers in Postman to simulate API responses during development or when the real API is unavailable.

3. Environment Variables in Tests: Access environment variables within your tests using pm.environment.get() for better management and organization.

4. Data-Driven Testing: Utilize data files (CSV, JSON, etc.) to populate various test data into your requests for more efficient and comprehensive testing.

8. The Postman CLI

Extend the capabilities of Postman by utilizing the Postman CLI (Command Line Interface).

1. Installation: Install the Postman CLI using npm:

Terminal window
npm install -g newman

2. Run Collections: Execute Postman collection runs directly from the command line:

Terminal window
newman run my-api-tests.postman_collection.json -e production.postman_environment.json

This command runs the collection “my-api-tests” with the environment “production”.

3. Reporting: Generate comprehensive reports in various formats (HTML, JSON) to analyze your test results.

By incorporating Postman within your Node.js development process, you gain a comprehensive API testing platform that accelerates your workflow and improves the quality of your applications. Remember to leverage Postman’s diverse features, including environments, collections, scripting, and the CLI, to streamline your testing tasks and enhance the accuracy of your results.

API Testing Blog