Jest Setup and Test Structure with describe, it, and expect

1// src/string-utils.ts
2export const truncate = (str: string, max: number): string =>
3  str.length <= max ? str : str.slice(0, max) + '...';
4
5export const capitalize = (str: string): string =>
6  str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
7
8export const countWords = (str: string): number =>
9  str.trim() === '' ? 0 : str.trim().split(/\s+/).length;
10
11// src/string-utils.test.ts
12import { truncate, capitalize, countWords } from './string-utils';
13
14describe('string-utils', () => {
15  describe('truncate', () => {
16    it('returns the original string when shorter than max', () => {
17      expect(truncate('Hello', 10)).toBe('Hello');
18    });
19
20    it('truncates and appends ellipsis when longer than max', () => {
21      expect(truncate('Hello, World!', 5)).toBe('Hello...');
22    });
23
24    it('returns the original string when equal to max', () => {
25      expect(truncate('Hello', 5)).toBe('Hello');
26    });
27  });
28
29  describe('capitalize', () => {
30    it('capitalises the first letter and lowercases the rest', () => {
31      expect(capitalize('hELLO')).toBe('Hello');
32    });
33  });
34
35  describe('countWords', () => {
36    it('returns 0 for an empty string', () => {
37      expect(countWords('')).toBe(0);
38    });
39
40    it('counts words separated by multiple spaces', () => {
41      expect(countWords('one  two   three')).toBe(3);
42    });
43  });
44});

1test('toBe vs toEqual', () => {
2  const a = { x: 1 };
3  const b = { x: 1 };
4
5  expect(a).not.toBe(b);       // different references — PASSES
6  expect(a).toEqual(b);        // same structure — PASSES
7  expect(a).toStrictEqual(b);  // same structure, same types — PASSES
8
9  expect(1 + 1).toBe(2);       // primitive — use toBe
10});
11
12test('string matchers', () => {
13  const msg = 'Hello, World!';
14  expect(msg).toContain('World');              // substring
15  expect(msg).toMatch(/^Hello/);               // regex
16  expect(msg).toHaveLength(13);                // length
17  expect(msg).not.toContain('Goodbye');        // negation
18});
19
20test('array matchers', () => {
21  const arr = [1, 2, 3, 4, 5];
22  expect(arr).toHaveLength(5);
23  expect(arr).toContain(3);
24  expect(arr).toEqual(expect.arrayContaining([2, 4])); // subset
25});
26
27test('object matchers', () => {
28  const user = { id: 1, name: 'Alice', role: 'admin', createdAt: new Date() };
29  // toMatchObject checks a subset of properties
30  expect(user).toMatchObject({ name: 'Alice', role: 'admin' });
31});
32
33test('error matchers', () => {
34  const dangerous = () => { throw new TypeError('bad input'); };
35  expect(dangerous).toThrow();
36  expect(dangerous).toThrow('bad input');     // message substring
37  expect(dangerous).toThrow(TypeError);       // error class
38  expect(dangerous).toThrow(/bad/);           // regex on message
39});

1import { UserService } from './user-service';
2
3describe('UserService', () => {
4  let service: UserService;
5
6  // Runs before every single test — guarantees a fresh instance
7  beforeEach(() => {
8    service = new UserService();
9  });
10
11  // Runs after every test — good for clearing mocks
12  afterEach(() => {
13    jest.clearAllMocks();
14  });
15
16  it('creates a user with a generated id', () => {
17    const user = service.create({ name: 'Alice', email: '[email protected]' });
18    expect(user.id).toBeDefined();
19    expect(user.name).toBe('Alice');
20  });
21
22  it('returns undefined for unknown ids', () => {
23    const user = service.findById('nonexistent');
24    expect(user).toBeUndefined();
25  });
26
27  it('lists only active users', () => {
28    service.create({ name: 'Alice', email: '[email protected]' });
29    service.create({ name: 'Bob', email: '[email protected]' });
30    service.deactivate('alice-id');
31    // Because beforeEach creates a fresh service, we start from zero
32    expect(service.listActive()).toHaveLength(2); // both users start active
33  });
34});

1describe('DB-heavy tests', () => {
2  let db: Database;
3
4  beforeAll(async () => {
5    db = await Database.connect(process.env['TEST_DATABASE_URL']!);
6  });
7
8  afterAll(async () => {
9    await db.disconnect();
10  });
11
12  beforeEach(async () => {
13    await db.truncateAll(); // still reset data per-test
14  });
15});

1# Run all tests once
2npx jest
3
4# Watch mode — re-runs only tests affected by changed files
5npx jest --watch
6
7# Run a single test file
8npx jest src/cart.test.ts
9
10# Run tests matching a name pattern (-t = test name)
11npx jest -t 'calculates subtotal'
12
13# Coverage report in terminal + HTML
14npx jest --coverage
15
16# Fail if coverage drops below thresholds
17npx jest --coverage --coverageThreshold='{"global":{"lines":80}}'
18
19# Run tests in a specific directory
20npx jest src/modules/auth
21
22# Show verbose output (each test name, not just file names)
23npx jest --verbose
24
25# Run tests in band (single process) — needed for tests sharing global state
26npx jest --runInBand
27
28# Update snapshots
29npx jest --updateSnapshot

1{
2  "scripts": {
3    "test": "jest",
4    "test:watch": "jest --watch",
5    "test:coverage": "jest --coverage",
6    "test:ci": "jest --coverage --runInBand --forceExit"
7  }
8}

1FAIL  src/cart.test.ts
2  calculateSubtotal
3    x calculates total correctly for multiple items (12 ms)
4
5  ● calculateSubtotal > calculates total correctly for multiple items
6
7    expect(received).toBe(expected)
8
9    Expected: 60
10    Received: 35
11
12      45 |   it('calculates total correctly for multiple items', () => {
13      46 |     const cart = addItem(addItem(emptyCart, sampleItem), anotherItem);
14    > 47 |     expect(calculateSubtotal(cart)).toBe(60);
15         |                                    ^
16      48 |   });
17
18    at Object.<anonymous> (src/cart.test.ts:47:36)

1// Pattern: use descriptive test names so the failure output reads like a spec
2it('returns the discounted price when a valid coupon is applied', () => {
3  // Failure output: "returns the discounted price when a valid coupon is applied"
4  // This sentence tells you exactly what went wrong without reading the code
5  expect(applyDiscount(100, 'SAVE20')).toBe(80);
6});