Unit Testing

What it is

A unit test verifies the smallest piece of behaviour in isolation — a function, a method, a class. It runs in memory, with all collaborators replaced by test doubles (stubs, mocks, spies), so a failure points at exactly one unit.

1
        ┌─────────────┐
2
        │  Unit under │   ← only this is real
3
        │    test     │
4
        └──────┬──────┘
5
       stub ───┤├─── mock      ← collaborators are fake

The defining properties: fast (milliseconds), deterministic (no clock, network or disk), isolated (no shared state between tests), and focused (one reason to fail).

When to use it / when to avoid it

Use it for

Pure logic: calculations, parsers, formatters, state reducers, validators
Boundary conditions and edge cases (0, empty, max, unicode)
Branches and error paths you can reach cheaply

Avoid or reduce it when

The unit is thin glue over a framework — you would be testing the framework
Everything is mocked away, so the test still passes when the wiring is broken
Behaviour is really about several units cooperating → use an integration test

Frameworks & tools

Framework	Ecosystem	Notes
Vitest	JS/TS	Vite-native, Jest-compatible API, built-in coverage
Jest	JS/TS	Most widely used; large plugin ecosystem
Mocha + Chai/Sinon	JS/TS	Flexible, unopinionated runner
pytest	Python	Fixtures, parametrise, huge plugin ecosystem
unittest	Python	Standard library, no dependencies
Go testing (`go test`)	Go	Built in; table-driven tests are idiomatic
Testify	Go	Assertions and mocks on top of `go test`
JUnit 5	Java/JVM	The JVM standard; parameterized tests
TestNG	Java/JVM	Suites, groups, parallel execution
xUnit	.NET	Modern, `[Fact]`/`[Theory]`
NUnit	.NET	Mature, data-driven `[TestCase]`
Rust `#[test]`	Rust	Built in via `cargo test`
PHPUnit	PHP	The PHP standard

Mocking/doubling: Sinon, Jest mocks, unittest.mock, mockito (Java), Moq/NSubstitute (.NET), testify/mock (Go), mockall (Rust).

Quick setup

1
npm install -D vitest
2
npx vitest run          # or `npx vitest` in watch mode

1
// vite.config.ts (optional)
2
import { defineConfig } from 'vite';
3
export default defineConfig({ test: { environment: 'node' } });

1
pip install pytest
2
pytest -q

1
go test ./...

1
<!-- Maven: JUnit 5 + Surefire -->
2
<dependency>
3
  <groupId>org.junit.jupiter</groupId>
4
  <artifactId>junit-jupiter</artifactId>
5
  <version>5.11.0</version>
6
  <scope>test</scope>
7
</dependency>

1
dotnet new xunit -o MyApp.Tests
2
dotnet test

Example

1
import { describe, it, expect, vi } from 'vitest';
2
import { calculateDiscount } from './discount';
3

4
describe('calculateDiscount', () => {
5
  it('applies 10% for orders over 100', () => {
6
    expect(calculateDiscount(200)).toBe(20);
7
  });
8

9
  it('applies no discount at the boundary', () => {
10
    expect(calculateDiscount(100)).toBe(0);
11
  });
12

13
  it('does not call the logger on the happy path', () => {
14
    const log = vi.fn();
15
    calculateDiscount(200, log);
16
    expect(log).not.toHaveBeenCalled();
17
  });
18
});

1
import pytest
2
from discount import calculate_discount
3

4
@pytest.mark.parametrize(
5
    ("total", "expected"),
6
    [(200, 20), (100, 0), (0, 0)],
7
)
8
def test_calculate_discount(total, expected):
9
    assert calculate_discount(total) == expected

1
func TestCalculateDiscount(t *testing.T) {
2
  tests := []struct {
3
    name  string
4
    total int
5
    want  int
6
  }{
7
    {"over threshold", 200, 20},
8
    {"at boundary", 100, 0},
9
  }
10
  for _, tc := range tests {
11
    t.Run(tc.name, func(t *testing.T) {
12
      if got := CalculateDiscount(tc.total); got != tc.want {
13
        t.Fatalf("want %d, got %d", tc.want, got)
14
      }
15
    })
16
  }
17
}

1
import static org.junit.jupiter.api.Assertions.assertEquals;
2
import org.junit.jupiter.params.ParameterizedTest;
3
import org.junit.jupiter.params.provider.CsvSource;
4

5
class DiscountTest {
6
  @ParameterizedTest
7
  @CsvSource({"200,20", "100,0", "0,0"})
8
  void appliesDiscount(int total, int expected) {
9
    assertEquals(expected, Discount.calculate(total));
10
  }
11
}

1
using Xunit;
2

3
public class DiscountTests
4
{
5
    [Theory]
6
    [InlineData(200, 20)]
7
    [InlineData(100, 0)]
8
    [InlineData(0, 0)]
9
    public void AppliesDiscount(int total, int expected)
10
    {
11
        Assert.Equal(expected, Discount.Calculate(total));
12
    }
13
}

Anti-patterns & best practices

Test behaviour, not implementation. Assert on outputs and observable state, not on how many times a private helper ran.
One main reason to fail per test. Name it after the behaviour (applies 10% for orders over 100), not the method.
Avoid over-mocking. If a test needs five mocks to run, the unit is too coupled.
No shared mutable fixtures. Tests must pass in any order and in parallel.
Cover boundaries. Off-by-one bugs live at 0, 1, max, empty, null.
Do not chase 100% coverage. Coverage shows what ran, not what was verified — use mutation testing for that.