Refactor, Unit Testing & Code Coverage

Testing Pyramid · Clean Code · Refactoring · AAA Pattern · Code Coverage · TDD

→ next slide  |  ESC overview

The Testing Pyramid

Not all tests are equal. We automate the ones that are cheap to run and give fast feedback.

What Is Clean Code?

Clean code is code that is easily understood by any team member — even 10 years from now.

• Simple to read and follow
• Easy to modify, extend, and maintain
• The same principles apply to test code as production code

Source: Robert C. Martin — Clean Code: A Handbook of Agile Software Craftsmanship

Clean Code — General Rules

Meaningful Names

// Bad ❌
let d;
let number;
let modymdhms;
let nameString;

// Bad ❌
function a(x, y) {
  return x - y;
}

// Good ✅
let elapsedTimeInDays;
let numberOfTasks;
let modificationTimestamp;
let name;

// Good ✅
function calculateDiscount(price, discount) {
  return price - discount;
}

Function Rules

// Bad ❌ — validates, calculates AND logs
function handleRental(age, days, rate) {
  if (age < 21 || age > 75) {
    console.log("Driver not eligible");
    return null;
  }
  let total = days * rate;
  if (days > 7) total = total * 0.9;
  console.log(`Total: €${total}`);
  return total;
}

// Good ✅ — each function does ONE thing
function isEligibleDriver(age) {
  return age >= 21 && age <= 75;
}

function calculateTotal(days, rate) {
  const base = days * rate;
  return days > 7 ? base * 0.9 : base;
}

function handleRental(age, days, rate) {
  if (!isEligibleDriver(age)) return null;
  return calculateTotal(days, rate);
}

Rules:
· Small
· Do one thing
· Descriptive name
· Prefer fewer arguments
· No side effects

Clean Code in Tests

Test code is code — it must be clean too.

FIRST: Fast · Independent · Repeatable · Self-validating · Timely

What Is Unit Testing?

Testing the smallest testable piece of code — a single function or method — in isolation from the rest of the system.

Arrange · Act · Assert

test('calculateDiscount returns correct price', () => {
  // Arrange
  const price = 100;
  const discountPercent = 20;

  // Act
  const result = calculateDiscount(price, discountPercent);

  // Assert
  expect(result).toBe(80);
});

Code Coverage

The percentage of code lines/branches/paths executed during testing.

function getDiscount(age) {
  if (age < 18) {        // Branch 1
    return 0.20;
  } else if (age > 65) { // Branch 2
    return 0.15;
  } else {               // Branch 3
    return 0.0;
  }
}
// Need 3 tests for 100% branch coverage

100% coverage doesn't mean 0 bugs. But <60% coverage is a red flag.

Running Coverage with Jest

# Run tests with coverage report
npm test -- --coverage
# Output:
# -------------------|---------|----------|---------|---------|
# File               | % Stmts | % Branch | % Funcs | % Lines |
# -------------------|---------|----------|---------|---------|
# rentalPrice.js     |   92.31 |    83.33 |     100 |   92.31 |
# -------------------|---------|----------|---------|---------|

"jest": {
  "coverageThreshold": {
    "global": {
      "branches": 90,
      "functions": 100,
      "lines": 90
    }
  }
}

Unit Testing Frameworks

Test-Driven Development

Write the test before writing the code. The test drives the implementation.

TDD = small, safe steps. Each cycle is minutes, not hours. Fail fast, fix fast.

TDD Example

test('calculateRentalCost works', () => {
  expect(calculateRentalCost(3, 50)).toBe(150);
});
// Test fails — function doesn't exist yet

function calculateRentalCost(days, dailyRate) {
  return days * dailyRate;
}
// Test passes!

// Add validation, handle edge cases,
// clean up names — tests still pass
function calculateRentalCost(days, dailyRate) {
  if (days <= 0 || dailyRate < 0) {
    throw new Error('Invalid input');
  }
  return days * dailyRate;
}

// Write another failing test for the
// edge case, then make it pass.

TDD — Worth It?

Using AI in Coding & Testing

AI tools (Copilot, ChatGPT, Cursor, Claude) are now part of the developer toolkit.
Use them — but use them with brains.

AI-generated code compiles. It might even pass basic tests. That doesn't make it correct.

TDD + AI — The Perfect Safety Net

TDD is the ideal framework for working with AI. You define correctness before AI touches the code.

Using AI Responsibly

AI is your junior developer who works fast and never complains — but always needs review.