Testing Pure Logic

function CartTotal({ items, coupon }) {
  let subtotal = 0
  for (const i of items) subtotal += i.price * i.qty
  const discount = coupon?.kind === 'percent'
    ? subtotal * coupon.value / 100
    : coupon?.value ?? 0
  const total = Math.max(0, subtotal - discount)
  return <p>{formatMoney(total)}</p>
}

// the test:
// render(<CartTotal items={...} coupon={...} />)
// expect(screen.getByText('£12.00')).toBeVisible()

export function cartTotal(items, coupon) {
  const subtotal = items.reduce((s, i) => s + i.price * i.qty, 0)
  const discount = coupon?.kind === 'percent'
    ? subtotal * coupon.value / 100
    : coupon?.value ?? 0
  return Math.max(0, subtotal - discount)
}

function CartTotal({ items, coupon }) {
  return <p>{formatMoney(cartTotal(items, coupon))}</p>
}

// the test:
// expect(cartTotal([], null)).toBe(0)
// expect(cartTotal(oneItem, percentOver100)).toBe(0)

The second form separates two failures that the first conflates: a wrong number and a number that never reached the screen. It also makes the cases nobody writes — empty cart, a coupon larger than the subtotal, a negative quantity — a one-line call instead of a fixture.

1// Impure: three hidden dependencies, none of them visible at the call site.
2export function trialBanner(user: User): string {
3  const daysLeft = Math.ceil((user.trialEndsAt - Date.now()) / 86_400_000)
4  return `${daysLeft} days left in your trial`
5}
6 
7// Pure: the clock, the locale and the timezone are arguments.
8export interface TrialCtx { now: number; locale: string; timeZone: string }
9 
10export function trialStatus(user: User, ctx: TrialCtx) {
11  const end = new Date(user.trialEndsAt)
12  const daysLeft = daysBetween(ctx.now, user.trialEndsAt, ctx.timeZone)
13  return {
14    daysLeft,
15    expired: daysLeft <= 0,
16    // written out rather than numeric, because this string is also read aloud
17    endsOn: new Intl.DateTimeFormat(ctx.locale, {
18      dateStyle: 'long', timeZone: ctx.timeZone,
19    }).format(end),
20  }
21}
22 
23// The cases that matter are now one call each:
24//   the last full day, the boundary instant, one second past it,
25//   a user in a timezone west of the server, a locale that formats
26//   the date the other way round.

The interesting assertion is not the happy path. It is that a user whose trial ends at midnight in Auckland and a user whose trial ends at the same instant in Los Angeles see different numbers of days left, and that both are correct.

• Money and quantity arithmetic — subtotals, tax, discounts, proration, rounding. Floating point is a real source of off-by-a-penny bugs and the assertions are trivial to write.
• Dates and durations — "days left", "expires today", scheduling windows, working days. Almost always wrong at a boundary, and always in a timezone you do not live in (Timezones and Locale Formatting).
• Pagination and range maths — page counts, offsets, clamping, what happens when the last item on the last page is deleted. Boundary logic pretending to be trivial (Pagination From the Interface Backwards).
• Sorting, grouping and filtering — including stability and tie-breaking, which users notice as rows jumping around between renders (Reconciliation and Keys).
• Validation and parsing — field rules, cross-field rules, and the parsing of anything that arrived as a string (Native Validation and Its Limits).
• State reducers — (state, action) => state, including the "ignore a stale response" rule that is otherwise untestable (State Synchronization).
• Permission derivation — turning a role or a claim set into what the UI offers, which is a decision function, not an authorization boundary (Authorization-Aware UI).
• Formatting — currency, units, plurals, truncation, and anything a screen reader will read out loud (Internationalization).

1. 1
   Name the rule

   Give it the name the business uses: cartTotal, daysLeftInTrial, pageAfterDelete.

   fails by A name like getData or helper, which means the boundary has not actually been found.

2. 2
   Move it, unchanged

   Cut the body out with no rewrite, so the commit is provably behaviour-preserving.

   fails by Improving it during the move, which makes any resulting bug impossible to attribute.

3. 3
   Lift the ambient inputs

   Clock, locale, timezone, flags and randomness become parameters.

   fails by Leaving one behind — usually the clock — so the test still fails on a machine in another timezone.

4. 4
   Write the boundaries

   Empty, one, exactly at the limit, one past, negative, absent, malformed.

   fails by Writing the happy path only, which is the case that was already working.

5. 5
   Delete what it replaced

   Remove the mounted tests that only existed to reach this arithmetic.

   fails by Keeping both, so the same rule is now maintained at two levels and one of them will drift.

Steps two and three are separate on purpose: a move and a signature change in one commit is a bug that nobody can bisect.