Unit Testing Best Practices: Write Tests That Actually Catch Bugs Before Production

// WRONG: testing implementation details
it('calls the formatDate helper', () => {
 const spy = jest.spyOn(utils, 'formatDate');
 renderComponent({ date: new Date() });
 expect(spy).toHaveBeenCalled(); // This tests HOW not WHAT
 // Passes even if the output is wrong!
 // Breaks when you rename formatDate even if behavior is unchanged
});

// RIGHT: test what the user/caller actually sees
it('displays date in MM/DD/YYYY format', () => {
 const { getByText } = render();
 expect(getByText('04/07/2026')).toBeInTheDocument();
 // Tests BEHAVIOR — passes as long as output is correct
 // Survives any internal refactoring
});

// WRONG: testing third-party library behavior
it('Array.map returns new array', () => { /* ... */ }); // They wrote that test!

// RIGHT: test YOUR code that uses the library
it('filters inactive users and returns sorted names', () => {
 const users = [{ name: 'Bob', active: false }, { name: 'Alice', active: true }];
 expect(getActiveUserNames(users)).toEqual(['Alice']);
});

// Every test has three clear sections:
describe('UserService.createUser', () => {
 it('sends welcome email after successful account creation', async () => {
 // ARRANGE: set up the world
 const emailService = { sendWelcome: jest.fn().mockResolvedValue(true) };
 const userRepo = { save: jest.fn().mockResolvedValue({ id: '123', name: 'Alice' }) };
 const service = new UserService(userRepo, emailService);

 // ACT: do the thing
 const result = await service.createUser({ name: 'Alice', email: 'alice@example.com' });

 // ASSERT: verify outcomes
 expect(result.id).toBe('123');
 expect(emailService.sendWelcome).toHaveBeenCalledWith(
 expect.objectContaining({ email: 'alice@example.com' })
 );
 });

 it('throws ValidationError when email is invalid', async () => {
 const service = new UserService(mockRepo, mockEmail);
 await expect(service.createUser({ name: 'Alice', email: 'not-an-email' }))
 .rejects.toThrow(ValidationError);
 });
});

// Mock at external boundaries: network, database, filesystem, time
// Do NOT mock internal functions or modules you wrote

// WRONG: mocking own code deeply
jest.mock('./utils/formatCurrency'); // Now testing with fake implementation
jest.mock('./services/calculateTax'); // Not testing real tax logic!

// RIGHT: mock external dependencies only
jest.mock('./db/client'); // Real boundary — DB calls
jest.mock('./email/smtp'); // Real boundary — email
jest.useFakeTimers(); // Real boundary — time

// Mock strategies:
// Spy: wrap real implementation, track calls
const spy = jest.spyOn(console, 'error').mockImplementation(() => {});

// Stub: replace with fake that returns specific value
const mockRepo = { findById: jest.fn().mockResolvedValue({ id: 1, name: 'Alice' }) };

// Fake: working implementation (in-memory DB for testing)
const repo = new InMemoryUserRepository(); // Behaves like real, fast, no I/O

describe('processOrder', () => {
 // Happy path (everyone writes this)
 it('processes valid order', async () => { /* ... */ });

 // Edge cases (where bugs hide)
 it('handles empty items array', async () => {
 await expect(processOrder({ items: [] })).rejects.toThrow('Order must have items');
 });
 it('handles null customer', async () => {
 await expect(processOrder({ customer: null, items: [item] })).rejects.toThrow();
 });
 it('handles item quantity of 0', async () => {
 await expect(processOrder({ items: [{ qty: 0 }] })).rejects.toThrow();
 });
 it('handles negative price', async () => { /* ... */ });
 it('handles order exactly at free shipping threshold', async () => { /* ... */ });
 it('handles concurrent orders for same item (race condition)', async () => { /* ... */ });
 it('rolls back if payment succeeds but inventory update fails', async () => { /* ... */ });
});