Testing

    will search in ./* and ./**/* recursively, for test files:

    • named test.{ts, tsx, mts, js, mjs, jsx, cjs, cts},
    • or ending with .test.{ts, tsx, mts, js, mjs, jsx, cjs, cts},
    • or ending with _test.{ts, tsx, mts, js, mjs, jsx, cjs, cts}

    To define a test you need to register it with a call to Deno.test API. There are multiple overloads of this API to allow for greatest flexibility and easy switching between the forms (eg. when you need to quickly focus a single test for debugging, using only: true option):

    You can also test asynchronous code by passing a test function that returns a promise. For this you can use the async keyword when defining a function:

    1. import { delay } from "https://deno.land/std@$STD_VERSION/async/delay.ts";
    3. Deno.test("async hello world", async () => {
    4.   const x = 1 + 2;
    6.   // await some async task
    7.   await delay(100);
    9.   if (x !== 3) {
    10.     throw Error("x should be equal to 3");
    11.   }
    12. });

    The test steps API provides a way to report distinct steps within a test and do setup and teardown code within that test.

    1. Deno.test("database", async (t) => {
    2.   const db = await Database.connect("postgres://localhost/test");
    4.   // provide a step name and function
    5.   await t.step("insert user", async () => {
    6.     const users = await db.query(
    7.       "INSERT INTO users (name) VALUES ('Deno') RETURNING *",
    8.     );
    9.     assertEquals(users.length, 1);
    10.     assertEquals(users[0].name, "Deno");
    11.   });
    13.   // or provide a test definition
    14.   await t.step({
    15.     name: "insert book",
    16.     fn: async () => {
    17.       const books = await db.query(
    18.         "INSERT INTO books (name) VALUES ('The Deno Manual') RETURNING *",
    19.       );
    20.       assertEquals(books.length, 1);
    21.       assertEquals(books[0].name, "The Deno Manual");
    22.     },
    23.     ignore: false,
    24.     // these default to the parent test or step's value
    25.     sanitizeOps: true,
    26.     sanitizeResources: true,
    27.     sanitizeExit: true,
    28.   });
    30.   // nested steps are also supported
    31.     await t.step("update", () => {
    32.       // even though this test throws, the outer promise does not reject
    33.       // and the next test step will run
    34.       throw new Error("Fail.");
    35.     });
    37.     await t.step("delete", () => {
    38.       // ...etc...
    39.     });
    40.   });
    43.   const testRan = await t.step({
    44.     name: "copy books",
    45.     fn: () => {
    46.       // ...etc...
    47.     },
    48.     ignore: true, // was ignored, so will return `false`
    49.   });
    51.   // steps can be run concurrently if sanitizers are disabled on sibling steps
    52.   const testCases = [1, 2, 3];
    53.   await Promise.all(testCases.map((testCase) =>
    54.     t.step({
    55.       name: `case ${testCase}`,
    56.       fn: async () => {
    57.         // ...etc...
    58.       },
    59.       sanitizeOps: false,
    60.       sanitizeResources: false,
    61.       sanitizeExit: false,
    62.     })
    63.   ));
    65.   db.close();
    66. });

    Outputs:

    1. test database ...
    2.   test insert user ... ok (2ms)
    3.   test insert book ... ok (14ms)
    4.   test update and delete ...
    5.     test update ... FAILED (17ms)
    6.       Error: Fail.
    7.           at <stack trace omitted>
    8.     test delete ... ok (19ms)
    9.   FAILED (46ms)
    10.   test copy books ... ignored (0ms)
    11.   test case 1 ... ok (14ms)
    12.   test case 2 ... ok (14ms)
    13.   test case 3 ... ok (14ms)
    14. FAILED (111ms)

    Notes:

    1. Test steps must be awaited before the parent test/step function resolves or you will get a runtime error.
    2. Test steps cannot be run concurrently unless sanitizers on a sibling step or parent test are disabled.
    3. If nesting steps, ensure you specify a parameter for the parent step.
      1. Deno.test("my test", (t) => {
      2.   await t.step("step", async (t) => {
      3.     // note the `t` used here is for the parent step and not the outer `Deno.test`
      4.     await t.step("sub-step", () => {
      5.     });
      6. });

    Nested test steps

    To run the test, call deno test with the file that contains your test function. You can also omit the file name, in which case all tests in the current directory (recursively) that match the glob {*_,*.,}test.{ts, tsx, mts, js, mjs, jsx, cjs, cts} will be run. If you pass a directory, all files in the directory that match this glob will be run.

    1. # Run all tests in the current directory and all sub-directories
    2. deno test
    4. # Run all tests in the util directory
    5. deno test util/
    7. # Run just my_test.ts
    8. deno test my_test.ts

    To see all runtime options with deno test, you can reference the command line help:

    1. deno help test

    There are a number of options to filter the tests you are running.

    Tests can be run individually or in groups using the command line --filter option.

    The filter flags accept a string or a pattern as value.

    Assuming the following tests:

    2. Deno.test({ name: "test-1", fn: test1 });
    3. Deno.test({ name: "test2", fn: test2 });

    This command will run all of these tests because they all contain the word “test”.

    1. deno test --filter "test" tests/

    On the flip side, the following command uses a pattern and will run the second and third tests.

    1. deno test --filter "/test-*\d/" tests/

    To let Deno know that you want to use a pattern, wrap your filter with forward-slashes like the JavaScript syntactic sugar for a REGEX.

    Filtering out (Ignoring these tests)

    Sometimes you want to ignore tests based on some sort of condition (for example you only want a test to run on Windows). For this you can use the ignore boolean in the test definition. If it is set to true the test will be skipped.

    1. Deno.test({
    2.   name: "do macOS feature",
    3.   ignore: Deno.build.os !== "darwin",
    4.   fn() {
    5.     doMacOSFeature();
    6.   },
    7. });

    Filtering in (Only run these tests)

    Sometimes you may be in the middle of a problem within a large test class and you would like to focus on just that test and ignore the rest for now. For this you can use the only option to tell the test framework to only run tests with this set to true. Multiple tests can set this option. While the test run will report on the success or failure of each test, the overall test run will always fail if any test is flagged with only, as this is a temporary measure only which disables nearly all of your tests.

    If you have a long-running test suite and wish for it to stop on the first failure, you can specify the --fail-fast flag when running the suite.

    1. deno test --fail-fast

    Deno’s test runner works with popular testing libraries like , Sinon.JS or .

    For example integration see:

    Test spies are function stand-ins that are used to assert if a function’s internal behavior matches expectations. Sinon is a widely used testing library that provides test spies and can be used in Deno by importing it from a CDN, such as Skypack:

    1. import sinon from "https://cdn.skypack.dev/sinon";

    Say we have two functions, foo and bar and want to assert that bar is called during execution of foo. There are a few ways to achieve this with Sinon, one is to have function foo take another function as a parameter:

    1. // my_file.js
    2. export function bar() {/*...*/}
    4. export function foo(fn) {
    5.   fn();
    6. }

    This way, we can call foo(bar) in the application code or wrap a spy function around bar and call foo(spy) in the testing code:

    1. import sinon from "https://cdn.skypack.dev/sinon";
    2. import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
    3. import { bar, foo } from "./my_file.js";
    5. Deno.test("calls bar during execution of foo", () => {
    6.   // create a test spy that wraps 'bar'
    7.   const spy = sinon.spy(bar);
    9.   // call function 'foo' and pass the spy as an argument
    10.   foo(spy);
    12.   assertEquals(spy.called, true);
    13.   assertEquals(spy.getCalls().length, 1);
    14. });
    1. // my_file.js
    2. function bar() {/*...*/}
    4. export const funcs = {
    5.   bar,
    6. };
    8. // 'foo' no longer takes a parameter, but calls 'bar' from an object
    9. export function foo() {
    10.   funcs.bar();
    11. }

    And then in a test file: