What are assertions in testing?

Question

Accepted Answer

**Assertions** are statements in a test that **check whether a condition is true** — verifying that the actual result matches the expected result. They're the core of how tests determine pass or fail: if an assertion fails, the test fails.

## What assertions do

```text
An ASSERTION checks that something is as expected:
  → "assert that the actual value EQUALS the expected value"
  → if TRUE → the assertion passes; if FALSE → the assertion FAILS → the TEST FAILS
→ Assertions are how a test VERIFIES behavior (the "check" part of a test).
```

## Common assertion types

```js
// equality
expect(result).toBe(5);                  // strict equality
expect(obj).toEqual({ name: 'Ann' });    // deep/value equality (objects)

// truthiness / null
expect(value).toBeTruthy();
expect(value).toBeNull();
expect(value).toBeDefined();

// comparisons
expect(count).toBeGreaterThan(0);
expect(price).toBeLessThanOrEqual(100);

// collections / strings
expect(array).toContain('item');
expect(array).toHaveLength(3);
expect(text).toMatch(/pattern/);          // regex

// errors
expect(() => risky()).toThrow();          // expect a function to throw

// negation
expect(value).not.toBe(null);
```

## Good assertions

```text
✓ Assert the SPECIFIC expected outcome (clear what's being checked)
✓ Use the RIGHT matcher (toBe vs toEqual; specific > generic)
✓ Clear FAILURE messages (good assertions/matchers explain what failed)
✓ Don't over-assert (test one behavior) or under-assert (verify the actual result)
```

## Why it matters

Understanding assertions is fundamental because they're **the core mechanism by which tests verify behavior** — determining pass or fail — so it's essential, must-know knowledge for writing any test.

An assertion **checks that a condition is true** (typically that an actual result matches an expected one), and it's the "verification" part of a test: if an assertion passes the check holds, and if it fails the test fails.

Without assertions, a test doesn't actually verify anything — so understanding them is fundamental to writing meaningful tests.

Understanding the **common assertion types** — equality (strict `toBe` vs deep/value `toEqual` for objects, an important distinction), truthiness and null checks, comparisons, collection and string checks, error assertions (verifying a function throws), and negation — is necessary practical knowledge for expressing what a test should verify.

Understanding **good assertion practices** — asserting the specific expected outcome (clear about what's checked), using the right matcher (e.g. `toEqual` for object comparison, not `toBe`), ensuring clear failure messages (so a failing test explains what went wrong), and balancing assertions (testing one behavior, but verifying the actual result) — reflects writing clear, effective tests.

Since assertions are how every test verifies behavior (the fundamental check that makes a test meaningful) and understanding them — the types, the right matchers, and good practices — is necessary to write any test that actually verifies something, understanding assertions is essential, foundational testing knowledge — the core building block of tests, necessary for expressing and verifying expected behavior, and fundamental to writing tests that meaningfully check correctness, a basic competency for anyone writing tests.