Code Coverage Analysis with Istanbul and Jest

1// src/discount.ts
2export function getDiscount(tier: 'bronze' | 'silver' | 'gold', price: number): number {
3  // Branch 1: tier === 'gold'       (true / false)
4  // Branch 2: tier === 'silver'     (true / false)
5  // Branch 3: price > 1000          (true / false)
6  if (tier === 'gold') {
7    return price * 0.25;
8  } else if (tier === 'silver') {
9    return price * 0.15;
10  } else {
11    return price > 1000 ? price * 0.1 : price * 0.05; // nested branch
12  }
13}
14
15// If we ONLY test:
16test('gold tier gets 25% off', () => {
17  expect(getDiscount('gold', 100)).toBe(25);
18});
19
20// Coverage result:
21// Statements: 2/5 = 40%
22// Branches:   2/8 = 25%  ← reveals the gap
23// Functions:  1/1 = 100% ← misleadingly high
24// Lines:      3/7 = 43%
25
26// After adding tests for silver, bronze < 1000, bronze > 1000:
27// Branches:   8/8 = 100%

1// jest.config.ts
2import type { Config } from 'jest';
3
4const config: Config = {
5  preset: 'ts-jest',
6  testEnvironment: 'node',
7
8  // Which files to measure coverage for (not just tested files)
9  collectCoverageFrom: [
10    'src/**/*.ts',
11    '!src/**/*.d.ts',          // exclude type declaration files
12    '!src/**/*.test.ts',       // exclude test files themselves
13    '!src/**/*.spec.ts',
14    '!src/index.ts',           // exclude barrel files (no logic)
15    '!src/**/migrations/**',   // exclude generated files
16  ],
17
18  // Coverage report formats
19  coverageReporters: [
20    'text',        // terminal summary table
21    'text-summary', // one-line summary
22    'lcov',        // for CI tools (SonarQube, Codecov)
23    'html',        // browser-viewable detailed report
24  ],
25
26  // Output directory
27  coverageDirectory: 'coverage',
28
29  // Minimum thresholds — build FAILS if any drops below these
30  coverageThreshold: {
31    global: {
32      statements: 80,
33      branches: 80,
34      functions: 85,
35      lines: 80,
36    },
37    // Per-file threshold for critical modules
38    './src/modules/auth/auth.service.ts': {
39      statements: 95,
40      branches: 90,
41      functions: 100,
42      lines: 95,
43    },
44  },
45};
46
47export default config;

1# Run with coverage
2npx jest --coverage
3
4# CI command (fails on threshold breach, exits cleanly)
5npx jest --coverage --coverageThreshold='{"global":{"branches":80}}'
6
7# Open HTML report
8npx jest --coverage && open coverage/lcov-report/index.html

1// src/auth.service.ts — example of what Istanbul annotates
2export function hashPassword(password: string, saltRounds = 10): string {
3  // ✅ GREEN: this line is covered
4  if (password.length < 8) {
5    // ✅ GREEN: covered by 'short password' test
6    throw new Error('Password too short');
7  }
8  // ✅ GREEN: covered
9  if (saltRounds < 1 || saltRounds > 20) {
10    // 🔴 RED: this branch never entered — no test for invalid saltRounds
11    throw new RangeError('saltRounds must be 1-20');
12  }
13  // ✅ GREEN: covered
14  return bcrypt.hashSync(password, saltRounds);
15}
16
17// Istanbul branch marker in HTML:
18// if (saltRounds < 1 || saltRounds > 20) {
19// I→  ← 'I' means the 'if' branch (true path) was not taken
20//     ← the 'E' (else path) was taken by other tests going past this guard

1// TRAP 1: Testing the happy path only
2export function parseJson(raw: string): unknown {
3  try {
4    return JSON.parse(raw);    // ✅ covered
5  } catch {
6    return null;               // 🔴 never tested — JSON.parse never throws in tests
7  }
8}
9
10test('parses valid JSON', () => {
11  expect(parseJson('{"a":1}')).toEqual({ a: 1 });
12  // Line coverage: 3/4 lines = 75% — but the catch is never hit
13  // Branch coverage: 1/2 = 50% — reveals the gap
14});
15
16// FIX: test the error branch
17test('returns null for invalid JSON', () => {
18  expect(parseJson('not json')).toBeNull();
19});
20
21// TRAP 2: Asserting coverage without asserting correctness
22test('processOrder runs without error', () => {
23  processOrder({ id: 'ORD-001', items: [] });
24  // No expect() — this executes the code (increases coverage) but verifies nothing
25  // 100% line coverage, 0 bugs caught
26});
27
28// TRAP 3: Mocking too aggressively
29test('createUser saves to database', async () => {
30  const save = jest.fn().mockResolvedValue({ id: 1 });
31  const result = await createUser({ name: 'Alice' }, { save }); // injected mock
32  expect(result.id).toBe(1);
33  // Branch coverage: high — but the real save() is never tested
34  // This is fine for unit tests, but integration tests must cover the real DB path
35});

1# Terminal output example:
2#
3# File                          | % Stmts | % Branch | % Funcs | % Lines
4# ------------------------------|---------|----------|---------|--------
5# src/auth/auth.service.ts      |   95.2  |   88.4   |  100.0  |   95.2
6# src/payment/payment.service.ts|   72.1  |   55.0   |   80.0  |   72.1  ← priority
7# src/cart/cart.utils.ts        |   100.0 |   93.7   |  100.0  |  100.0
8# src/email/email.service.ts    |   45.2  |   30.0   |   60.0  |   45.2  ← critical gap
9
10# email.service.ts at 30% branch coverage — open the HTML report:
11# open coverage/lcov-report/src/email/email.service.ts.html

1// Workflow for closing coverage gaps:
2// 1. Open HTML report for the file with lowest branch coverage
3// 2. Find the red/yellow annotated branches
4// 3. Write the simplest test that exercises that branch
5// 4. Re-run coverage to confirm the branch turns green
6
7// Example: discovered uncovered branch in email-service.ts
8// The 'else' branch of: if (process.env['EMAIL_ENABLED'] !== 'true') { return; }
9
10// Gap test:
11test('skips sending when EMAIL_ENABLED is not true', async () => {
12  const original = process.env['EMAIL_ENABLED'];
13  process.env['EMAIL_ENABLED'] = 'false';
14
15  const sendSpy = jest.spyOn(smtpTransport, 'send');
16  await sendWelcomeEmail('[email protected]');
17
18  expect(sendSpy).not.toHaveBeenCalled();
19
20  process.env['EMAIL_ENABLED'] = original; // restore
21});