Verify API pagination returns correct data and navigation

Preconditions (2)

Step 1: Send a GET request to /items?page=1&limit=5

Step 2: Verify the response status code is 200

Step 3: Verify the response body contains exactly 5 items

Step 4: Note the total number of items from the response metadata

Step 5: Send a GET request to /items?page=2&limit=5

Step 6: Verify the response status code is 200

Step 7: Verify the response body contains the next 5 items

Step 8: Verify that no items from page 1 appear on page 2

Step 9: Send a GET request to /items?page=lastPage&limit=5 where lastPage is calculated from total items

Step 10: Verify the response status code is 200

Step 11: Verify the response body contains the remaining items (less than or equal to 5)

Step 12: Send a GET request to /items?page=0&limit=5

Step 13: Verify the response status code is 400 or appropriate error code

Step 14: Send a GET request to /items?page=1&limit=0

Step 15: Verify the response status code is 400 or appropriate error code

✅ Expected Result: API returns correct paginated data for valid pages with correct status codes and errors for invalid page or limit values

Automation Requirements - Postman Tests (JavaScript)

Assertions Needed:

Status code is 200 for valid requests

Response body contains expected number of items

No duplicate items between pages

Status code is 400 for invalid page or limit values

Best Practices:

Use pm.expect for assertions

Parse JSON response safely

Use variables to store total items and calculate last page

Write clear and descriptive test names

Avoid hardcoding values except for test inputs

Automated Solution

Postman

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

const jsonData = pm.response.json();

pm.test('Response has 5 items for page 1', () => {
    pm.expect(jsonData.items.length).to.eql(5);
});

// Store total items count for later use
pm.environment.set('totalItems', jsonData.total);

// Store items from page 1 for comparison
pm.environment.set('page1Items', JSON.stringify(jsonData.items));

// Calculate last page
const limit = 5;
const totalItems = pm.environment.get('totalItems');
const lastPage = Math.ceil(totalItems / limit);
pm.environment.set('lastPage', lastPage);

// Additional tests for page 2 and last page should be in separate requests using these variables

// Example test for page 2 (to be run in a separate request):
/*
pm.test('Status code is 200 for page 2', () => {
    pm.response.to.have.status(200);
});
const page2Data = pm.response.json();
pm.test('Response has 5 items for page 2', () => {
    pm.expect(page2Data.items.length).to.eql(5);
});

const page1Items = JSON.parse(pm.environment.get('page1Items'));
const page2Items = page2Data.items;

pm.test('No duplicate items between page 1 and page 2', () => {
    const page1Ids = page1Items.map(item => item.id);
    const page2Ids = page2Items.map(item => item.id);
    const duplicates = page2Ids.filter(id => page1Ids.includes(id));
    pm.expect(duplicates.length).to.eql(0);
});
*/

// Tests for invalid page and limit values:
pm.test('Status code is 400 for invalid page 0', () => {
    pm.response.to.have.status(400);
});

pm.test('Status code is 400 for invalid limit 0', () => {
    pm.response.to.have.status(400);
});

This Postman test script checks the API pagination step-by-step.

First, it verifies the status code is 200 for a valid page 1 request.

Then it checks that exactly 5 items are returned as expected.

It saves the total number of items and the items from page 1 in environment variables for later use.

It calculates the last page number based on total items and limit.

Additional tests for page 2 and last page are shown as comments because they should be run in separate requests using the saved variables.

It also includes tests for invalid page and limit values expecting a 400 error status.

This approach uses best practices like pm.expect assertions, environment variables for sharing data between requests, and clear test names.

Common Mistakes - 4 Pitfalls

Not checking the status code before parsing the response body

Hardcoding page numbers and limits without using variables

Not verifying that items between pages do not overlap

Ignoring error cases like invalid page or limit values

Bonus Challenge

Now add data-driven testing with 3 different page and limit combinations to verify pagination works for various inputs

Show Hint