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 7/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 1m total length

Course Overview7:25
How the Course Is Conducted11:10
How to Use CodeSandbox0:11
Link to codesandbox0:02

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 with an internet connection and a modern browser (Chrome recommended) is all you need. We use codesandbox, so there is no Node.js install or setup at all.
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.

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 • 19min

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: