Jest Testing with Mock Data: Complete Guide

Why Mock Data in Jest?

Jest is JavaScript's most popular testing framework, and mock data is essential for writing effective tests. Mock data allows you to test components in isolation, control test scenarios, and avoid dependencies on external systems like databases or APIs. This makes tests faster, more reliable, and easier to maintain.

Method 1: Simple Mock Data Constants

// __mocks__/mockData.js
export const mockUser = {
  id: '123',
  name: 'John Doe',
  email: 'john@example.com',
  role: 'admin'
};

export const mockUsers = [
  mockUser,
  { id: '456', name: 'Jane Smith', email: 'jane@example.com', role: 'user' },
  { id: '789', name: 'Bob Johnson', email: 'bob@example.com', role: 'user' }
];

// userService.test.js
import { mockUser, mockUsers } from './__mocks__/mockData';

describe('UserService', () => {
  test('finds user by id', () => {
    const result = findUserById('123', mockUsers);
    expect(result).toEqual(mockUser);
  });
});

Method 2: Mocking API Calls

// api/users.js
export async function fetchUsers() {
  const response = await fetch('/api/users');
  return response.json();
}

// api/__mocks__/users.js
export const fetchUsers = jest.fn(() =>
  Promise.resolve([
    { id: '1', name: 'John Doe', email: 'john@test.com' },
    { id: '2', name: 'Jane Smith', email: 'jane@test.com' }
  ])
);

// UserList.test.js
jest.mock('./api/users');
import { fetchUsers } from './api/users';
import { renderUserList } from './UserList';

test('renders user list from API', async () => {
  const users = await fetchUsers();
  const result = renderUserList(users);

  expect(fetchUsers).toHaveBeenCalledTimes(1);
  expect(result).toContain('John Doe');
  expect(result).toContain('Jane Smith');
});

Method 3: Jest Mock Functions

// Testing callbacks with mock data
test('calls callback with user data', () => {
  const mockCallback = jest.fn();
  const mockUser = { id: '1', name: 'Test User' };

  processUser(mockUser, mockCallback);

  expect(mockCallback).toHaveBeenCalledWith(mockUser);
  expect(mockCallback).toHaveBeenCalledTimes(1);
});

// Mock return values
test('returns transformed user data', () => {
  const getUserById = jest.fn();
  getUserById.mockReturnValue({ id: '1', name: 'John' });

  const user = getUserById('1');
  expect(user.name).toBe('John');
});

// Mock different responses
test('handles multiple scenarios', () => {
  const api = jest.fn();

  api
    .mockReturnValueOnce({ success: true, data: mockUser1 })
    .mockReturnValueOnce({ success: false, error: 'Not found' });

  expect(api()).toEqual({ success: true, data: mockUser1 });
  expect(api()).toEqual({ success: false, error: 'Not found' });
});

Method 4: Factory Functions for Mock Data

// __mocks__/factories.js
export function createMockUser(overrides = {}) {
  return {
    id: '123',
    name: 'Test User',
    email: 'test@example.com',
    createdAt: new Date('2024-01-01'),
    role: 'user',
    ...overrides
  };
}

export function createMockUsers(count = 3) {
  return Array.from({ length: count }, (_, i) =>
    createMockUser({
      id: String(i + 1),
      name: `User ${i + 1}`,
      email: `user${i + 1}@example.com`
    })
  );
}

// Using in tests
test('handles admin users differently', () => {
  const adminUser = createMockUser({ role: 'admin' });
  const result = processUser(adminUser);
  expect(result.permissions).toContain('delete');
});

test('processes multiple users', () => {
  const users = createMockUsers(10);
  const result = processUserBatch(users);
  expect(result.length).toBe(10);
});

Testing with External Mock Data

// Generate large dataset with our tool, save as mockUsers.json

// userService.test.js
import mockUsers from './__mocks__/mockUsers.json';

describe('UserService with large dataset', () => {
  test('filters users by role', () => {
    const admins = filterUsersByRole(mockUsers, 'admin');
    expect(admins.length).toBeGreaterThan(0);
    admins.forEach(user => {
      expect(user.role).toBe('admin');
    });
  });

  test('paginates users correctly', () => {
    const page1 = paginateUsers(mockUsers, 1, 10);
    const page2 = paginateUsers(mockUsers, 2, 10);

    expect(page1.length).toBe(10);
    expect(page2.length).toBe(10);
    expect(page1[0].id).not.toBe(page2[0].id);
  });
});

Best Practices

1. Keep Mock Data Close to Tests

Store mock data in __mocks__ directories next to your test files for easy access and maintenance.

2. Use Factory Functions

Create factory functions for flexibility. Override specific properties while using defaults for the rest.

3. Test Edge Cases

Create mock data for null values, empty arrays, extreme values, and error states to ensure robust error handling.

4. Reset Mocks Between Tests

Use jest.clearAllMocks() inbeforeEach() to ensure test isolation.

Generate Test Data for Jest

Create comprehensive mock datasets for your Jest tests instantly. Perfect for unit and integration testing!

Generate Mock Data →

Conclusion

Mock data is essential for effective Jest testing. Whether using simple constants, factory functions, or external datasets, the key is to create realistic, maintainable test data that covers both happy paths and edge cases. This approach leads to more reliable tests and better code quality.