Async test patterns in Deno - Step-by-Step Execution

Concept Flow - Async test patterns

Write async test function

↓

Run test runner

↓

Test runner calls async function

↓

Await async operations inside test

↓

Check assertions after await

↓

Test passes or fails

↓

Report result

This flow shows how an async test function is written and executed by the test runner, waiting for async operations before checking results.

Execution Sample

Deno

import { assertEquals } from "https://deno.land/std/testing/asserts.ts";

Deno.test("async addition test", async () => {
  const result = await new Promise((r) => setTimeout(() => r(2 + 3), 0));
  assertEquals(result, 5);
});

This code defines an async test that waits for a Promise to resolve before asserting the result.

Execution Table

Step	Action	Async Operation	Awaited Result	Assertion	Test Outcome
1	Test runner starts async test function	None yet	N/A	None yet	Running
2	Execute new Promise(r => setTimeout(() => r(2 + 3), 0))	Promise created	Pending	None yet	Running
3	Await Promise resolution	Promise resolved	5	None yet	Running
4	Call assertEquals(5, 5)	None	N/A	Pass	Running
5	Test function completes	None	N/A	Pass	Passed

💡 Test completes after awaiting async operation and assertion passes

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
result	undefined	Promise {<pending>}	5	5

Key Moments - 2 Insights

Why do we use 'await' inside the test function?

Because the test runner waits for the async function to finish, 'await' pauses execution until the Promise resolves, ensuring assertions check the final result (see execution_table step 3).

What happens if we forget to 'await' the Promise?

The assertion might run before the Promise resolves, causing incorrect test results or false passes/fails (not shown in table but would fail at step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'result' after Step 3?

A 5

B Promise {<pending>}

C undefined

D null

💡 Hint

Check the 'Awaited Result' and 'Variable' columns at Step 3 in execution_table and variable_tracker

At which step does the test runner confirm the test has passed?

A Step 3

B Step 4

C Step 5

D Step 2

💡 Hint

Look at the 'Test Outcome' column in execution_table for when the test status changes to 'Passed'

If we remove 'await' before new Promise(r => setTimeout(() => r(2 + 3), 0)), how would the 'result' variable change after Step 2?

A It would be undefined

B It would be a pending Promise

C It would be 5 immediately

D It would throw an error

💡 Hint

Refer to variable_tracker and understand that without 'await', the Promise remains pending after assignment

Concept Snapshot

Async test patterns in Deno:
- Define test with async function
- Use 'await' to pause for async operations
- Assertions run after awaited results
- Test runner waits for async test completion
- Ensures reliable async code testing

Full Transcript

This visual execution trace shows how async test patterns work in Deno. First, you write an async test function that returns a Promise. The test runner calls this function and waits for it to complete. Inside the test, you use 'await' to pause execution until the Promise resolves. After awaiting, assertions check the results. The test passes if assertions succeed. The variable 'result' changes from a pending Promise to the resolved value after awaiting. Forgetting 'await' can cause tests to run assertions too early, leading to errors. The execution table tracks each step, showing how the async operation progresses and when the test passes.

Practice

1. What is the main reason to use async and await in Deno test functions?

easy

A. To automatically retry failed tests

B. To make tests run faster by skipping delays

C. To avoid writing any assertions in tests

D. To handle code that involves waiting or delays smoothly

Solution

1. Step 1: Understand async/await purpose

   Async/await lets code wait for operations like fetching data or timers before continuing.

2. Step 2: Connect async/await to testing

   In tests, async/await ensures the test waits for the code under test to finish before checking results.

3. Final Answer:

   To handle code that involves waiting or delays smoothly -> Option D

4. Quick Check:

   Async tests wait properly = A [OK]

Hint: Async tests wait for promises to resolve before asserting [OK]

Common Mistakes:

• Thinking async makes tests faster
• Skipping await and causing false positives
• Confusing async with retry logic

2. Which of the following is the correct way to declare an async test in Deno?

easy

A. Deno.test(() => { await someAsyncFunc(); });

B. Deno.test(async () => { await someAsyncFunc(); });

C. async Deno.test(() => { someAsyncFunc(); });

D. Deno.test(async function someAsyncFunc() {});

Solution

1. Step 1: Check async function syntax in test

   The test function must be declared async to use await inside it.

2. Step 2: Validate each option

   Deno.test(async () => { await someAsyncFunc(); }); correctly declares an async arrow function with await inside. Deno.test(() => { await someAsyncFunc(); }); misses async keyword. async Deno.test(() => { someAsyncFunc(); }); has invalid syntax. Deno.test(async function someAsyncFunc() {}); passes an async function but without calling it properly.

3. Final Answer:

   Deno.test(async () => { await someAsyncFunc(); }); -> Option B

4. Quick Check:

   Async arrow function with await = A [OK]

Hint: Async test functions need async keyword before () => [OK]

Common Mistakes:

• Omitting async keyword before arrow function
• Trying to await outside async function
• Incorrect async function syntax in test

3. What will be the output when running this Deno test?

import { assertEquals } from "https://deno.land/std/testing/asserts.ts";

Deno.test("delayed test", async () => {
  const result = await new Promise((resolve) => setTimeout(() => resolve(42), 100));
  assertEquals(result, 42);
});

medium

A. Test passes after 100ms delay

B. Test fails immediately with assertion error

C. SyntaxError due to incorrect async usage

D. Test times out and fails

Solution

1. Step 1: Analyze the async test code

   The test waits 100ms using a Promise with setTimeout, then resolves with 42.

2. Step 2: Check assertion correctness

   The test asserts that the resolved value is 42, which matches the expected value.

3. Final Answer:

   Test passes after 100ms delay -> Option A

4. Quick Check:

   Awaited promise resolves correctly = D [OK]

Hint: Await promises to ensure test waits for async results [OK]

Common Mistakes:

• Expecting immediate test pass without await
• Confusing assertion values
• Assuming syntax error without checking code

4. Identify the error in this Deno async test code:

import { assertEquals } from "https://deno.land/std/testing/asserts.ts";

Deno.test("broken test", () => {
  const result = await Promise.resolve(10);
  assertEquals(result, 10);
});

medium

A. assertEquals is not imported correctly

B. Promise.resolve cannot be awaited

C. Missing async keyword before the test function

D. Test name is invalid

Solution

1. Step 1: Check async usage in test function

   The test function uses await but is not declared async, which causes a syntax error.

2. Step 2: Verify other parts

   assertEquals is imported correctly, Promise.resolve can be awaited, and test name is valid.

3. Final Answer:

   Missing async keyword before the test function -> Option C

4. Quick Check:

   Await requires async function = B [OK]

Hint: Add async before test function to use await inside [OK]

Common Mistakes:

• Forgetting async keyword with await
• Assuming Promise.resolve can't be awaited
• Misreading import statements

5. You want to test a function fetchData() that returns a promise resolving to an object. Which pattern correctly tests it with Deno's async test and handles errors gracefully?

hard

A. Deno.test("fetchData test", async () => {
try {
const data = await fetchData();
assert(data !== null);
} catch {
throw new Error("fetchData failed");
}
});

B. Deno.test("fetchData test", () => {
fetchData().then(data => assert(data !== null));
});

C. Deno.test("fetchData test", async () => {
const data = await fetchData();
assert(data !== null);
});

D. Deno.test("fetchData test", async () => {
fetchData().catch(() => {});
assert(true);
});

Solution

1. Step 1: Understand async test with error handling

   Using async/await with try/catch allows catching errors and failing the test properly.

2. Step 2: Evaluate each option

   Deno.test("fetchData test", async () => { const data = await fetchData(); assert(data !== null); }); lacks error handling, so test may silently fail. Deno.test("fetchData test", () => { fetchData().then(data => assert(data !== null)); }); is not async and may finish before promise resolves. Deno.test("fetchData test", async () => { try { const data = await fetchData(); assert(data !== null); } catch { throw new Error("fetchData failed"); } }); uses async/await with try/catch correctly. Deno.test("fetchData test", async () => { fetchData().catch(() => {}); assert(true); }); ignores errors and asserts true regardless.

3. Final Answer:

   Deno.test("fetchData test", async () => { try { const data = await fetchData(); assert(data !== null); } catch { throw new Error("fetchData failed"); } }); -> Option A

4. Quick Check:

   Async test with try/catch for errors = C [OK]

Hint: Use async/await with try/catch to catch errors in tests [OK]

Common Mistakes:

• Not awaiting promises in tests
• Ignoring errors causing false passes
• Using then() without returning promise in test