What is unit testing?

Question

Accepted Answer

**Unit testing** verifies individual **units** of code (functions, methods, classes) in **isolation** — checking that each small piece works correctly on its own. Unit tests are fast, focused, and form the foundation of a good testing strategy.

## What a unit test is

```text
A UNIT test verifies the smallest testable piece (a function/method) in ISOLATION:
  → test ONE thing; give inputs, check the output/behavior
  → ISOLATED from dependencies (database, network, other units) — mock/stub those
  → FAST (no real I/O), focused, deterministic
```

## Example

```js
// the function under test
function add(a, b) { return a + b; }

// a unit test (Jest)
test('add returns the sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);          // input → expected output
  expect(add(-1, 1)).toBe(0);         // test cases, including edge cases
});

// test logic/behavior of a single unit
test('Cart.total sums item prices', () => {
  const cart = new Cart();
  cart.add({ price: 10 });
  cart.add({ price: 5 });
  expect(cart.total).toBe(15);
});
```

## Characteristics of good unit tests

```text
✓ FAST — run in milliseconds (so you run many, often)
✓ ISOLATED — test one unit; mock external dependencies; independent of other tests
✓ DETERMINISTIC — same result every time (no flakiness)
✓ Test BEHAVIOR/outcomes (not implementation details); clear and readable
✓ Cover normal cases, EDGE CASES, and error conditions
```

## Why it matters

Understanding unit testing is fundamental because **unit tests are the foundation of a good testing strategy** — the base of the test pyramid — so it's essential, must-know knowledge.

A unit test verifies the **smallest testable piece of code (a function or method) in isolation**, checking it works correctly on its own with given inputs producing expected outputs.

Understanding this — testing one thing at a time, isolated from dependencies (mocking external systems like databases and networks), fast and deterministic — is the core of unit testing.

Unit tests are valuable because they're **fast** (running in milliseconds, so you can run many frequently for quick feedback), **focused** (pinpointing exactly what broke when they fail), and form the **foundation** that most of a test suite should consist of.

Understanding the **characteristics of good unit tests** — fast, isolated (mocking dependencies, independent of other tests), deterministic (no flakiness), testing behavior and outcomes (not implementation details, so tests don't break on refactoring), and covering normal cases, edge cases, and error conditions — is important for writing effective tests that provide real value rather than brittle or low-value ones.

Unit testing is the most common and foundational form of testing, central to TDD, CI/CD, and confident development.

Since unit tests are the foundation of testing (the base of the pyramid, the most numerous and frequently-run tests) and understanding what they are and how to write good ones (isolated, fast, focused, testing behavior) is essential for any testing strategy, understanding unit testing is essential, foundational knowledge — the cornerstone of software testing that every developer should understand and practice, fundamental to verifying code correctness and enabling the confident, safe development that good testing provides.