Vitest 50 Drills: TypeScript Unit Testing from the Ground Up

Don't just memorize Jest-style APIs. Master Vitest in 50 drills: mocks, fake timers, fixtures, snapshots, types, CI.

Created byM Sakai

Last updated 10/2026

English

What you'll learn

Understand Vitest's execution model and its link to Vite, and explain why TypeScript/ESM tests run zero-config, wielding `globals` and `environment` correctly.
Design assertions that convey intent: three equality levels `toBe`/`toEqual`/`toStrictEqual`, asymmetric matchers, and custom matchers via `expect.extend`.
Compose fixtures with `test.extend` into a dependency graph, and design test preconditions that balance speed and isolation using `auto` and `scope:"worker"`.
Choose among `vi.fn`/`vi.spyOn`/`vi.mock`/`vi.stubGlobal`/`vi.stubEnv` per target, and correctly handle the three-tier clear/reset/restore and ESM hoisting.
Test async deterministically without waiting real time: `resolves`/`rejects`, `*Async` fake timers, `vi.waitFor`, `test.concurrent`, and `retry`/`repeats`.
Verify temporary-file I/O, in-memory SQLite, and a Hono+zod HTTP API with "real but fast" integration tests, and swap dependencies via dependency injection.
Put Vitest-only weapons to work in practice: snapshots, in-source tests, type tests with `expectTypeOf`, and benchmarks with `bench`.
Configure a coverage-threshold gate and unit/integration separation via `projects`, and build a locally reproducible mock CI to operationalize your tests.

Course content

12 sections • 104 lectures • 7h 5m total length

Course Overview7:25
How the Course Is Conducted11:10
Google Cloud Shell documentation and usage limits0:39
Exercise materials and Google Cloud Shell setup3:46

Q03 Three levels of equality — toBe vs toEqual vs toStrictEqual5:06
【Review】Q03 Three levels of equality — how to decide which to pick3:57
Q04 Target-specific matchers — write "meaning," not booleans5:03
【Review】Q04 Target-specific matchers — comparing failure messages3:34
Q05 Asymmetric matchers — verify unpredictable values by type/part4:38
【Review】Q05 Asymmetric matchers — writing tests that won't turn brittle3:43
Q06 Every form of exception check — sync and async errors4:23
【Review】Q06 Every form of exception check — the two required rules3:30
Q07 Custom matchers — write your own assertion4:21
【Review】Q07 Custom matchers — type augmentation and reuse points3:35
Q08 Soft assertions — report failures together, guarantee count4:23
【Review】Q08 Soft assertions — preventing slip-through accidents3:38

Q09 describe tree structure — control tests with only, skip, todo5:00
【Review】Q09 describe tree structure — tips for using todo well3:47
Q10 Data-driven with each — verify many cases at once4:58
【Review】Q10 Data-driven with each — naming tests for readability4:03
Q11 Cartesian with describe — run combinations as a matrix4:33
【Review】Q11 Cartesian with describe — how to think about nesting3:44
Q12 for and TestContext — the new form that takes local expect4:30
【Review】Q12 for and TestContext — the difference from each3:49

Q13 Hook execution order — when and how often All and Each run4:51
【Review】Q13 Hook execution order — the speed vs isolation trade-off3:52
Q14 Fixtures with extend — inject values only into tests that need4:19
【Review】Q14 Fixtures with extend — the line between setup and teardown3:36
Q15 Composing fixtures — stack preconditions in a dependency graph4:32
【Review】Q15 Composing fixtures — designing small pieces you layer up3:30
Q16 Auto fixtures and scope — share heavy init across a worker5:00
【Review】Q16 Auto fixtures and scope — a recap of the options4:16
Q17 setupFiles and globalSetup — per-run vs one-time preparation4:42
【Review】Q17 setupFiles and globalSetup — the difference in timing3:33

Q18 Spy basics — verify if called, with what args, how many times4:53
【Review】Q18 Spy basics — reading the raw call-history data3:35
Q19 clear, reset and restore — the three-tier mock reset5:17
【Review】Q19 clear, reset and restore — sorting out the essential difference4:18
Q20 Watching existing methods — observe while keeping the impl4:25
【Review】Q20 Watching existing methods — spy vs replacement boundary3:35
Q21 Module mocks and hoisting — through to partial mocks4:49
【Review】Q21 Module mocks and hoisting — why it sometimes doesn't work3:58
Q22 Replacing global APIs — try fetch logic with no network4:03
【Review】Q22 Replacing global APIs — choosing the tool per target3:20
Q23 Stubbing env vars — test behavior that changes by config4:18
【Review】Q23 Stubbing env vars — confirming the auto-restore mechanism3:29
Q24 Fake timers — advance time to verify debounce4:12
【Review】Q24 Fake timers — tests that don't wait real time[3:00
Q25 Side effects — seed exceptions and sequential responses4:35
【Review】Q25 Side effects — test design for retry logic3:41

Q26 Async test basics — wait with resolves and rejects4:06
【Review】Q26 Async test basics — don't forget the leading await3:34
Q27 Fake timers and Promises — why only the Async version resolves4:09
【Review】Q27 Fake timers and Promises — sorting out microtasks3:24
Q28 Wait until conditions hold — waitFor vs waitUntil4:05
【Review】Q28 Wait until conditions hold — vs hand-rolled polling3:20
Q29 Parallel execution — shorten wait time with concurrent4:21
【Review】Q29 Parallel execution — why local expect is required3:18
Q30 Flaky countermeasures — face unstable tests with retry/repeats4:15
【Review】Q30 Flaky countermeasures — why retry shouldn't be routine3:26

Q31 Capturing logs — verify console output4:08
【Review】Q31 Capturing logs — key points of side-effect testing3:24
Q32 Temp file I/O — an isolated directory per test4:36
【Review】Q32 Temp file I/O — why it never collides under parallelism3:35
Q33 Round-trip — save, read back, and confirm they match4:39
【Review】Q33 Round-trip — a two-part success and failure path3:23
Q34 Repository over SQLite — try real SQL in memory4:33
【Review】Q34 Repository over SQLite — handling a test database4:02
Q35 DB fixture reuse strategy — connect once, dirty every time4:03
【Review】Q35 DB fixture reuse strategy — a recap of the balanced design3:37

Q36 HTTP endpoints — verify routing without starting a server3:36
【Review】Q36 HTTP endpoints — confirming the basic test shape2:59
Q37 POST and validation — try whether bad input is rejected4:05
【Review】Q37 POST and validation — sorting out the split of duties3:35
Q38 Swap via dependency injection — inject a mock DB and test4:31
【Review】Q38 Swap via dependency injection — recap of the design's payoff3:32
Q39 HTTP error handling — pin down the 404 as a spec3:52
【Review】Q39 HTTP error handling — the idea of contract testing3:13
Q40 Async HTTP as-is — await and hit it with no extra config4:18
【Review】Q40 Async HTTP as-is — sorting out the difference from other langs3:38

Q41 Intro to snapshots — pin output without writing expected values3:57
【Review】Q41 Intro to snapshots — update workflow and when to use3:14
Q42 Inline vs file — choose the storage place by purpose4:15
【Review】Q42 Inline vs file — confirming why await is needed3:47
Q43 Custom serializers — erase the noise of ever-changing values4:19
【Review】Q43 Custom serializers — snapshots that don't break3:21

Requirements

Able to read and write basic JavaScript/TypeScript (variables, functions, classes, `import`/`export`, `async`/`await`). No framework knowledge is needed.
A PC, browser and Google account with verified age 18 or above. Upload the supplied ZIP and run its setup script in Cloud Shell. Free allowance: 50 hours/week, 5 GB home. Local Node.js 24 is an alternative.
No testing experience required. Even if you've never written a single test, the course is built so you can start from the very first test in Chapter 0.

Description

This course contains the use of artificial intelligence.

I can copy Jest's syntax. But I can't explain why it's written that way. — This course exists to get you out of exactly that state.

Vitest is a test runner that reuses Vite's transform pipeline directly to execute your tests. Once you grasp this single fact, everything connects on one line: why TypeScript runs with zero config, why `vi.mock` takes effect before your imports, why Promises don't resolve under fake timers. This course builds up that "how it works" understanding systematically through 50 hands-on drills.

Learning follows a roadmap of 10 chapters. Chapter 0 nails down Vitest's execution model. Chapter 1 covers the "three levels of equality" (`toBe` / `toEqual` / `toStrictEqual`), asymmetric matchers, and even writing your own custom matchers. Chapter 2 covers data-driven testing with `test.each` / `describe.each` / `test.for`; Chapter 3 covers hook execution order and the dependency graph and scope design of Vitest's fixture mechanism `test.extend`.

Chapter 4 is a full system for mocks. The three-tier reset distinction of `mockClear` / `mockReset` / `mockRestore` that trips up so many learners, and the hoisting behavior of `vi.mock`, are made to click through running code. Chapter 5 conquers async testing end to end: `resolves` / `rejects`, fake timers × Promises, `vi.waitFor`, `test.concurrent`, and `retry` for flaky tests.

From Chapter 6 we turn to real targets. You'll build designs that verify temporary-file I/O, the repository pattern over in-memory SQLite (`node:sqlite`), and HTTP APIs with Hono and zod as "real I/O, but fast and deterministic." Chapter 7's snapshots show how to remove noise with custom serializers; Chapter 8 covers Vitest-only weapons: in-source tests, type tests (`expectTypeOf`), benchmarks (`bench`), and browser mode. The final chapter closes with a coverage-threshold gate, unit/integration separation via `projects`, and a capstone that implements `PriceCalculator` via TDD and builds a mock CI.

Not just becoming able to write tests, but becoming able to design tests. That is the goal of this course.

Practice in Google Cloud Shell by uploading the exercise ZIP and running the included setup script. Node 24+ is required; no local Node installation is needed. A Google account is required. Free quotas: 50 hours/week, 5GB. Accounts under 18 or with unknown age cannot use Cloud Shell. A local Node alternative is included. Follow the updated startup lecture when videos show CodeSandbox. Grading requires no API keys or paid Cloud resources.

Who this course is for:

JavaScript/TypeScript developers who can copy Jest's syntax but feel they can't explain "why it's written that way."
Beginner-to-intermediate learners who want to start frontend/Node.js test automation without getting stuck on environment setup.
Engineers considering a move from Jest to Vitest, or already using Vitest but frequently tripping up on mocks and async tests.
Those with test-framework experience in other languages (e.g. pytest) who want to port that knowledge to JavaScript/TypeScript by the shortest path.
Team leads and tech leads who want to learn test design as a "team safety net," including coverage thresholds and CI pipelines.

Vitest 50 Drills: TypeScript Unit Testing from the Ground Up

What you'll learn

Explore related topics

Course content

Introduction4 lectures • 23min

Vitest's worldview and your first test4 lectures • 19min

Understanding expect and matchers deeply12 lectures • 50min

Structuring and data-driven tests8 lectures • 34min

Lifecycle and fixtures10 lectures • 42min

A system for mocks16 lectures • 1hr 5min

Mastering async10 lectures • 38min

Testing files and databases10 lectures • 40min

Testing an HTTP API10 lectures • 37min

Snapshots6 lectures • 23min

Requirements

Description

Who this course is for: