What is a unit testWhat is unit test?An automated check that verifies a single function works correctly in isolation, with all external dependencies replaced by fakes. Ask AI for more?

A unit is the smallest testable piece of code, typically a single function, method, or component. A unit test verifies that this piece works correctly in isolation, without databases, APIs, or other modules.

function calculateDiscount(price, percentage) {
  if (price < 0) throw new Error('Price cannot be negative');
  if (percentage < 0 || percentage > 100) {
    throw new Error('Percentage must be between 0 and 100');
  }
  return price * (percentage / 100);
}

test('calculateDiscount() applies percentage correctly', () => {
  expect(calculateDiscount(100, 20)).toBe(20);
  expect(calculateDiscount(50, 10)).toBe(5);
  expect(calculateDiscount(0, 50)).toBe(0);
});

test('calculateDiscount() throws on invalid input', () => {
  expect(() => calculateDiscount(-10, 20)).toThrow('Price cannot be negative');
  expect(() => calculateDiscount(100, 150)).toThrow('Percentage must be between 0 and 100');
});

Each test focuses on one aspect: correct calculation or error handling. This separation makes failures easy to diagnose. When AI generates this function, it will usually generate the first test but skip the second, it does not think to test its own error handling.

The AAA pattern

Every well-structured test follows three steps:

• Arrange: set up the test data and preconditions
• Act: execute the code under test
• Assert: verify the result matches expectations

test('shopping cart calculates total correctly', () => {
  // Arrange
  const cart = new ShoppingCart();
  const item1 = { price: 10, quantity: 2 };
  const item2 = { price: 5, quantity: 1 };

  // Act
  cart.add(item1);
  cart.add(item2);
  const total = cart.getTotal();

  // Assert
  expect(total).toBe(25);
});

When AI generates tests, it usually follows this structure. What it gets wrong is the content of each step, it arranges trivial data, acts on the happy path, and asserts shallow properties.

Testing frameworks: Jest and Vitest

Jest is the most popular JavaScript testing framework. Vitest is the modern alternative, faster, native TypeScript support, and built for Vite projects.

import { describe, test, expect } from 'vitest';
import { add, subtract, multiply } from './math';

describe('Math utilities', () => {
  test('add() returns sum of two numbers', () => {
    expect(add(2, 3)).toBe(5);
    expect(add(-1, 1)).toBe(0);
    expect(add(0, 0)).toBe(0);
  });

  test('subtract() returns difference', () => {
    expect(subtract(5, 3)).toBe(2);
    expect(subtract(3, 5)).toBe(-2);
  });
});

Both use the same APIWhat is api?A set of rules that lets one program talk to another, usually over the internet, by sending requests and getting responses. Ask AI for more (describe, test, expect), so switching between them is straightforward. When AI generates test files, check which framework it targets, mixing Jest globals with Vitest imports causes confusing failures.

Common assertions

Assertions are how you verify results. Here are the ones you will use most:

Mocking dependencies

Unit tests should be isolated. If your function calls an APIWhat is api?A set of rules that lets one program talk to another, usually over the internet, by sending requests and getting responses. Ask AI for more or database, you mockWhat is mock?A fake replacement for a real dependency in tests that records how it was called so you can verify interactions. Ask AI for more (fake) that dependencyWhat is dependency?A piece of code written by someone else that your project needs to work. Think of it as a building block you import instead of writing yourself. Ask AI for more so the test only exercises your logic.

import { vi } from 'vitest';

// Mock the API module
vi.mock('./api', () => ({
  fetchUser: vi.fn(() => Promise.resolve({ id: 1, name: 'Alice' }))
}));

test('loadUserProfile formats display name', async () => {
  const profile = await loadUserProfile(1);
  expect(profile.displayName).toBe('Alice');
});

Mocking lets you control the environment and test scenarios that are hard to reproduce, network failures, timeout errors, empty responses.

Testing async code

Modern JavaScript is full of async operations. Tests handle them with async/await:

test('fetches user data', async () => {
  const data = await fetchUser(1);
  expect(data.name).toBe('Alice');
});

test('handles missing user', async () => {
  await expect(fetchUser(999)).rejects.toThrow('User not found');
});

Always await the assertionWhat is assertion?A statement in a test that checks whether a value matches what you expected, failing the test if it does not. Ask AI for more when testing rejected promises. Forgetting await makes the test pass regardless of what the promiseWhat is promise?An object that represents a value you don't have yet but will get in the future, letting your code keep running while it waits. Ask AI for more does, the test finishes before the promise settles. When AI generates async tests, it sometimes forgets the await on rejects.toThrow(), creating a test that never fails.

What AI-generated unit tests typically miss

Here is a pattern you will see repeatedly. AI writes this test suite for a validateEmail function:

// AI-generated tests (looks complete, is not)
test('accepts valid email', () => {
  expect(validateEmail('user@example.com')).toBe(true);
});

test('rejects email without @', () => {
  expect(validateEmail('userexample.com')).toBe(false);
});

test('rejects empty string', () => {
  expect(validateEmail('')).toBe(false);
});

Three tests, all pass. But what about these cases?

// Tests AI should have written
test('rejects email with spaces', () => {
  expect(validateEmail('user @example.com')).toBe(false);
});

test('handles null input', () => {
  expect(validateEmail(null)).toBe(false);
});

test('handles undefined input', () => {
  expect(validateEmail(undefined)).toBe(false);
});

test('rejects double dots in domain', () => {
  expect(validateEmail('user@example..com')).toBe(false);
});

test('handles extremely long input', () => {
  const longEmail = 'a'.repeat(1000) + '@example.com';
  expect(validateEmail(longEmail)).toBe(false);
});

The AI tested the obvious cases. The real bugs live in the non-obvious ones. This is not a one-off problem, it is the pattern with every AI-generated test suite.

Unit testing decision table

When reviewing AI-generated tests or writing your own, use this table to decide what to test:

Unit testing best practices

Unit tests are your first line of defense. They catch logic errors early, document expected behavior, and give you confidence to refactor AI-generated code. But only if you write them to challenge the code, not confirm it.