d5c00ef50e
This commit lets `deno test --doc` command actually evaluate code snippets in JSDoc and markdown files. ## How it works 1. Extract code snippets from JSDoc or code fences 2. Convert them into pseudo files by wrapping them in `Deno.test(...)` 3. Register the pseudo files as in-memory files 4. Run type-check and evaluation We apply some magic at the step 2 - let's say we have the following file named `mod.ts` as an input: ````ts /** * ```ts * import { assertEquals } from "jsr:@std/assert/equals"; * * assertEquals(add(1, 2), 3); * ``` */ export function add(a: number, b: number) { return a + b; } ```` This is virtually transformed into: ```ts import { assertEquals } from "jsr:@std/assert/equals"; import { add } from "files:///path/to/mod.ts"; Deno.test("mod.ts$2-7.ts", async () => { assertEquals(add(1, 2), 3); }); ``` Note that a new import statement is inserted here to make `add` function available. In a nutshell, all items exported from `mod.ts` become available in the generated pseudo file with this automatic import insertion. The intention behind this design is that, from library user's standpoint, it should be very obvious that this `add` function is what this example code is attached to. Also, if there is an explicit import statement like `import { add } from "./mod.ts"`, this import path `./mod.ts` is not helpful for doc readers because they will need to import it in a different way. The automatic import insertion has some edge cases, in particular where there is a local variable in a snippet with the same name as one of the exported items. This case is addressed by employing swc's scope analysis (see test cases for more details). ## "type-checking only" mode stays around This change will likely impact a lot of existing doc tests in the ecosystem because some doc tests rely on the fact that they are not evaluated - some cause side effects if executed, some throw errors at runtime although they do pass the type check, etc. To help those tests gradually transition to the ones runnable with the new `deno test --doc`, we will keep providing the ability to run type-checking only via `deno check --doc`. Additionally there is a `--doc-only` option added to the `check` subcommand too, which is useful when you want to type-check on code snippets in markdown files, as normal `deno check` command doesn't accept markdown. ## Demo https://github.com/user-attachments/assets/47e9af73-d16e-472d-b09e-1853b9e8f5ce --- Closes #4716 |
||
---|---|---|
.. | ||
add | ||
bench | ||
bundle/removed | ||
cache | ||
cert | ||
check | ||
clean/general | ||
cli/help_and_version_broken_pipe | ||
compile | ||
coverage | ||
doc | ||
eval | ||
flags | ||
fmt | ||
future | ||
import_map/import_map_config | ||
info | ||
info_tests | ||
init/lib | ||
install | ||
jsr | ||
jupyter/install_command | ||
lint | ||
lockfile | ||
node | ||
node_compat_tests | ||
npm | ||
permission | ||
publish | ||
remove | ||
run | ||
serve | ||
task | ||
test | ||
upgrade/invalid_version | ||
vendor/removed | ||
worker | ||
workspaces | ||
mod.rs | ||
README.md | ||
schema.json |
specs
These are integration tests that execute the deno
binary. They supersede the
itest
macro found in the tests/integration
folder and are the preferred way
of writing tests that use the deno
binary.
Structure
Tests must have the following directory structure:
tests/specs/<category_name>/<test_name>/__test__.json
Test filtering
To run a specific test, run:
cargo test specs::category_name::test_name
Or just the following, though it might run other tests:
cargo test test_name
To run showing the output of every test use -- --nocapture
(note: this will
cause tests to run sequentially instead of in parallel):
cargo test test_name -- --nocapture
__test__.json
file
This file describes the test(s) to execute and the steps to execute. A basic example looks like:
{
"args": "run main.js",
"output": "main.out"
}
This will run deno run main.js
then assert that the output matches the text in
main.out
.
Or another example that runs multiple steps:
{
"tempDir": true,
"steps": [{
"args": "cache main.ts",
"output": "cache.out"
}, {
"args": "run main.ts",
"output": "error.out",
"exitCode": 1
}]
}
Or if you want to run several tests at the same time:
{
"tests": {
"ignore_dir": {
"args": "run script.ts",
"output": "script.out"
},
"some_other_test": {
"args": "run other.ts",
"output": "other.out"
}
}
}
Top level properties
repeat
(number) - Number of times to repeat a test.tempDir
(boolean) - Copy all the non-test files to a temporary directory and execute the command in that temporary directory.- By default, tests are executed with a current working directory of the test, but this may not be desirable for tests such as ones that create a node_modules directory.
Step properties
When writing a single step, these may be at the top level rather than nested in a "steps" array or "tests" object.
args
- A string (that will be spilt on whitespace into an args array) or an array of arguments.output
- Path to use to assert the output or text (must end with an .out extension) or text to pattern match against the output.flaky
- Step should be repeated until success a maximum of 3 times.if
("windows"
,"linux"
,"mac"
,"unix"
) - Whether to run this step.exitCode
(number) - Expected exit code.
Auto-complete
To get auto-complete for these files, add the following to a local
.vscode/settings.json
file:
{
"json.schemas": [{
"fileMatch": [
"__test__.jsonc"
],
"url": "./tests/specs/schema.json"
}]
}
.out
files
.out
files are used to assert the output when running a test or test step.
Within the file, you can use the following for matching:
[WILDCARD]
- match any text at the wildcard[WILDLINE]
- match any text on the current line[WILDCHAR]
- match the next character[WILDCHARS(5)]
- match any of the next 5 characters[UNORDERED_START]
followed by many lines then[UNORDERED_END]
will match the lines in any order (useful for non-deterministic output)[# example]
- line comments start with[#
and end with]