Skip to content
Postman API Testing Tips

How To Write Test Cases For Api Testing Using Postman

API Testing Blog

Mastering API Testing with Postman: A Comprehensive Guide to Writing Effective Test Cases

Postman is a powerful tool for API testing, offering a user-friendly interface and robust features to streamline your testing process. This guide will walk you through writing effective test cases for API testing using Postman, encompassing practical examples and step-by-step instructions.

1. Understanding the Basics of API Testing with Postman

Before diving into test case creation, let’s establish a solid foundation:

  • API Testing Fundamentals: API testing focuses on validating the functionality, reliability, and security of web services by sending requests and analyzing responses.
  • Postman’s Role: Postman acts as a versatile platform for crafting these requests, executing them, and analyzing results. It simplifies the testing process, enabling you to manage API requests, define test scenarios, and generate reports.

2. Setting Up Your Postman Workspace

  1. Create a New Collection: Collections in Postman help organize your API tests. Think of them as folders for grouping related requests and tests.
  2. Add a New Request: Inside a collection, create a request representing an API endpoint you wish to test.
  3. Specify Request Details: Define the method (GET, POST, PUT, DELETE), URL, headers, and body parameters for your request.

Example:

Method: GET

URL: https://reqres.in/api/users

Headers:

  • Content-Type: application/json

Body (optional): null

3. Writing Test Cases for Different API Operations

Now, let’s explore how to write test cases for common API operations:

3.1. Testing GET Requests:

Scenario: Verify the retrieval of data from the users endpoint

Test Case:

// Sample response data
const responseBody = pm.response.json();


// Test Case 1: Verify that the status code is 200 (OK)
pm.test("Status code is 200", () => {
  pm.expect(pm.response.code).to.be.equal(200);
});


// Test Case 2: Verify that the response body contains a data array
pm.test("Response contains data array", () => {
  pm.expect(responseBody.data).to.be.an("array");
});


// Test Case 3: Verify that the data array is not empty
pm.test("Data array is not empty", () => {
  pm.expect(responseBody.data).to.have.length.greaterThan(0);
});


// Test Case 4: Verify that each user object has a specific property (e.g., "email")
pm.test("Each user has email property", () => {
  responseBody.data.forEach(user => {
    pm.expect(user).to.have.property("email");
  });
});

3.2. Testing POST Requests:

Scenario: Create a new user

Test Case:

// Sample request body
const requestBody = {
  "name": "John Doe",
  "job": "Tester"
};


// Test Case 1: Verify that the status code is 201 (Created)
pm.test("Status code is 201", () => {
  pm.expect(pm.response.code).to.be.equal(201);
});


// Test Case 2: Verify that the response body contains the created user data
pm.test("Response contains created user data", () => {
  pm.expect(pm.response.json()).to.have.property("name", "John Doe");
  pm.expect(pm.response.json()).to.have.property("job", "Tester");
});

3.3. Testing PUT Requests:

Scenario: Update an existing user

Test Case:

// Sample request body
const requestBody = {
  "name": "Jane Doe"
};


// Test Case 1: Verify that the status code is 200 (OK)
pm.test("Status code is 200", () => {
  pm.expect(pm.response.code).to.be.equal(200);
});


// Test Case 2: Verify that the response body contains the updated user data
pm.test("Response contains updated user data", () => {
  pm.expect(pm.response.json()).to.have.property("name", "Jane Doe");
});

3.4. Testing DELETE Requests:

Scenario: Delete a user

Test Case:

// Test Case 1: Verify that the status code is 204 (No Content)
pm.test("Status code is 204", () => {
  pm.expect(pm.response.code).to.be.equal(204);
});


// Test Case 2: Verify that the response body is empty
pm.test("Response body is empty", () => {
  pm.expect(pm.response.text()).to.be.empty;
});

4. Parameterizing Test Data for Enhanced Coverage

To achieve comprehensive testing, it’s crucial to test various input combinations. Postman offers effective parameterization techniques:

4.1. Using Environment Variables:

  • Define environment variables within Postman’s environment manager.
  • Utilize these variables in your requests (e.g., URLs, headers, body parameters).
  • Create multiple environments to represent different configurations (development, testing, production) and switch between them seamlessly.

4.2. Implementing Data Files:

  • Store test data in JSON, CSV, or other supported file formats.
  • Use the pm.iterationData object to access data from these files during your tests.
  • Loop through data points, executing your API calls with diverse input values.

Example:

// Using a JSON data file for user data
pm.test("Verify user creation with different data", () => {
  const userData = pm.iterationData.get("userData");
  pm.expect(pm.response.json()).to.have.property("name", userData.name);
  pm.expect(pm.response.json()).to.have.property("job", userData.job);
});

5. Leveraging Assertions for Robust Validation

Postman provides powerful assertions for validating diverse aspects of your API responses:

5.1. Common Assertions:

  • pm.expect(actualValue).to.be.equal(expectedValue): Checks if the actual value matches the expected value.
  • pm.expect(actualValue).to.be.an("array"): Verifies if the actual value is an array.
  • pm.expect(actualValue).to.have.length.greaterThan(0): Checks if the array length is greater than zero.
  • pm.expect(actualValue).to.have.property(propertyName): Verifies if an object has a specific property.
  • pm.expect(actualValue).to.not.be.undefined: Checks if the actual value is not undefined.
  • pm.expect(actualValue).to.be.a("number"): Checks if the actual value is a number.

5.2. Custom Assertions:

  • Implement your own custom assertions using JavaScript functions, expanding the validation capabilities beyond built-in assertions.

Example:

// Custom assertion for validating API response time
function responseTimeValidator(responseTime) {
  pm.test("Response time:", () => {
    pm.expect(responseTime).to.be.lessThan(500); // Expect response time < 500ms
  });
}


// Using the custom assertion
const responseTime = pm.response.responseTime;
responseTimeValidator(responseTime);

6. Generating Reports for Detailed Analysis

Postman offers reporting features that help you track test results and identify areas for improvement:

6.1. Built-in Reports:

  • Generate reports directly from Postman to visualize test execution summaries, pass/fail rates, and detailed logs.

6.2. Integration with Third-Party Tools:

  • Connect Postman to tools like Jenkins for continuous integration and automated report generation.

7. Best Practices for Effective Test Case Writing

  • Coverage: Ensure that your test cases cover various scenarios, including positive, negative, and edge cases.
  • Clarity: Write test cases clearly and concisely, using meaningful variable names and comments.
  • Independence: Aim for independent test cases, where each case tests a specific aspect of the API without relying on the success of others.
  • Maintenance: Regularly update your test cases to reflect any changes made to the API.

By following these best practices and using Postman’s powerful features, you can craft comprehensive test cases that contribute to robust API testing and ensure high-quality software solutions.

API Testing Blog