TDD with Node.js and TypeScript

Section 1: Principles of Test-Driven Development

• The problems with writing tests afterwards and the benefits of writing them first
• The red-green-refactor cycle and the three rules of TDD
• The testing pyramid (unit, integration, end-to-end) and the testing trophy
• TDD when AI helps write code: tests as a specification you can verify
• Lab: analyse untested code and write a first test that defines the behaviour you want

Section 2: Setting Up a Node.js and TypeScript Project

• Node.js 24 LTS and running TypeScript with type stripping
• TypeScript 7 (the native compiler) for type checking, and tools that still need TypeScript 6
• Configuring tsconfig and ES modules
• Installing and configuring Vitest, compared with node:test
• Lab: create a starter project that runs tests and type checks with a single command

Section 3: Writing Good Unit Tests

• The describe, test and expect structure
• The Arrange-Act-Assert pattern and naming tests after behaviour
• Common matchers, and testing exceptions and async functions
• Parameterised tests with test.each to cut duplication
• Lab: rework hard-to-read tests so they are short, clear and not brittle

Section 4: TDD Kata Practice

• Practise the TDD cycle on short exercises such as String Calculator
• Fake It, Triangulation and Obvious Implementation
• Refactoring safely with tests as a safety net
• Lab: do a kata in pairs with ping-pong pairing, swapping between writing tests and writing code

Section 5: Workshop Day 1: ParcelPoint Domain Logic

• Calculate shipping costs by weight and zone test-first
• Apply discount coupons with their conditions and edge cases
• A state machine for parcel status: Created, Picked Up, In Transit, Delivered and Cancelled
• Workshop: refactor the domain logic for readability while every test still passes

Section 6: Designing Code for Testability

• Splitting code into route, service and repository layers
• Simple dependency injection without a framework
• An introduction to ports and adapters (hexagonal architecture)
• Lab: extract a service's dependencies behind interfaces so it can be tested

Section 7: Test Doubles

• The differences between dummies, stubs, spies, mocks and fakes
• Using vi.fn, vi.spyOn and vi.mock
• Controlling time with fake timers
• The dangers of over-mocking
• Lab: test the customer notification service with a mock and test expiry times with fake timers

Section 8: TDD with REST APIs

• Outside-in TDD, from the endpoint down to the service
• Testing Express 5 with Supertest: status codes, headers and bodies
• Validating input with Zod and testing validation errors
• Testing error-handling middleware
• Lab: build the create-parcel endpoint, always writing the Supertest test first

Section 9: Testing Authentication and Authorisation

• Testing endpoints that need a token, for both allowed and denied cases
• Testing role-based access
• Building test helpers for each user role to reduce duplication
• Lab: add a rule that only staff can cancel a parcel, starting from a failing test

Section 10: Workshop Day 2: The ParcelPoint REST API

• Endpoints to create, search, update the status of and cancel parcels, with a test written before each one
• An in-memory fake repository in place of the database
• A mock for the customer notification service
• Workshop: review the test suite together and fix tests that are too tied to internal details

Section 11: Integration Testing with Testcontainers

• The limits of mocking the database and why you need to test against a real one
• Using @testcontainers/postgresql to start a temporary PostgreSQL instance
• Migrating the schema and preparing test fixtures
• Isolating data between tests and cutting run time with global setup
• Lab: run repository tests against real PostgreSQL in a container

Section 12: Code Coverage

• Line, branch and function coverage with Vitest coverage (V8)
• Setting coverage thresholds that suit the project
• The limits of coverage as a measure of test quality
• Lab: read the coverage report and add tests for untested branches

Section 13: Mutation Testing with StrykerJS

• How mutation testing works and what the mutation score means
• Setting up StrykerJS with the Vitest runner
• Analysing surviving mutants and improving the tests
• Lab: raise the mutation score of the domain logic by strengthening weak assertions

Section 14: Bringing TDD into CI and Team Practice

• Running unit and integration tests in CI with GitHub Actions or GitLab CI
• A quality gate based on tests, coverage and type checks
• Applying TDD to legacy code with characterisation tests
• Code reviews that give tests proper attention
• Lab: set up a pipeline that blocks merging when tests fail

Section 15: Master Workshop: A Production-ready ParcelPoint

• Replace the fake repository with real PostgreSQL through Testcontainers and write integration tests for the main flows
• Run coverage and StrykerJS to find weak tests and improve them
• Add an express delivery fee feature test-first, from the first test to the endpoint
• Set up a CI pipeline with a quality gate, then present the result and review the code together