Testing async code in Node.js - Step-by-Step Execution

Concept Flow - Testing async code

Start Test

↓

Call async function

↓

Wait for Promise to resolve

↓

Check resolved value

↓

Pass

↓

Test Ends

The test calls an async function, waits for its result, then checks if the result matches the expected value to pass or fail.

Execution Sample

Node.js

test('fetch data returns correct value', async () => {
  const data = await fetchData();
  expect(data).toBe('hello');
});

This test waits for fetchData() to finish and checks if it returns 'hello'.

Execution Table

Step	Action	Promise State	Value/Result	Test Status
1	Test starts, calls fetchData()	Pending	No value yet	Running
2	Await fetchData() resolves	Resolved	'hello'	Running
3	Check if data === 'hello'	Resolved	true	Pass
4	Test ends	Resolved	N/A	Pass

💡 Test ends after assertion passes with resolved value 'hello'

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
data	undefined	undefined	'hello'	'hello'	'hello'

Key Moments - 3 Insights

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

Because fetchData() returns a Promise, 'await' pauses the test until the Promise resolves, ensuring we check the actual returned value (see execution_table step 2).

What happens if we forget to use 'async' before the test function?

The test won't wait for the Promise to resolve and may finish too early, causing false passes or failures (test status won't reflect the async result).

Why is the test status 'Running' before the Promise resolves?

Because the async function is still waiting for the Promise to finish, so the test is not complete yet (execution_table step 1 and 2).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'data' after step 2?

A null

B 'hello'

C undefined

D Promise

💡 Hint

Check the 'Value/Result' column at step 2 in the execution_table.

At which step does the test check the resolved value?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the step where the condition 'data === "hello"' is evaluated in the execution_table.

If we remove 'await' from the test, what will likely happen?

A Test may finish before Promise resolves

B Test will wait correctly

C Test will fail immediately

D Test will throw a syntax error

💡 Hint

Refer to key_moments about the importance of 'await' in async tests.

Concept Snapshot

Testing async code in Node.js:
- Use 'async' keyword on test function
- Use 'await' to wait for Promise results
- Assert on resolved values
- Ensures tests run only after async work finishes
- Prevents false positives or negatives

Full Transcript

Testing async code means writing tests that wait for asynchronous operations to finish before checking results. In Node.js, this is done by marking the test function as async and using 'await' to pause execution until the Promise resolves. The test then compares the resolved value to the expected result. This prevents tests from ending too early and gives accurate pass/fail results. The execution flow starts with calling the async function, waiting for it to resolve, then asserting the value. Variables like 'data' change from undefined to the resolved value during the test. Forgetting 'await' or 'async' causes the test to behave incorrectly by not waiting for the async operation.

Practice

1. What is the main reason to use async and await in Node.js tests?

easy

A. To make the test run faster by skipping waits

B. To automatically retry failed tests

C. To wait for asynchronous code to finish before checking results

D. To convert synchronous code into asynchronous code

Solution

1. Step 1: Understand async behavior in tests

   Async code runs in the background, so tests must wait for it to finish to check results correctly.

2. Step 2: Role of async/await in tests

   Using async/await pauses the test until the async code completes, ensuring accurate result checking.

3. Final Answer:

   To wait for asynchronous code to finish before checking results -> Option C

4. Quick Check:

   async/await waits for async code [OK]

Hint: Async tests must wait for completion before assertions [OK]

Common Mistakes:

• Thinking async/await speeds up tests
• Ignoring async code completion before assertions
• Confusing async/await with retries

2. Which of the following is the correct syntax to write an async test function in Node.js using Jest?

easy

A. test('example', () => { await asyncFunc(); });

B. async test('example', () => { asyncFunc(); });

C. test async('example', () => { asyncFunc(); });

D. test('example', async () => { await asyncFunc(); });

Solution

1. Step 1: Identify correct async test syntax

   Jest requires the test callback to be marked async to use await inside it.

2. Step 2: Check each option

   test('example', async () => { await asyncFunc(); }); correctly marks the callback async and uses await inside. Others either miss async or misuse syntax.

3. Final Answer:

   test('example', async () => { await asyncFunc(); }); -> Option D

4. Quick Check:

   async keyword before test callback [OK]

Hint: Async test functions need async keyword before callback [OK]

Common Mistakes:

• Omitting async keyword on test callback
• Using await outside async function
• Incorrect placement of async keyword

3. Consider this test code snippet:

test('fetch data returns correct value', async () => {
  const data = await fetchData();
  expect(data).toBe('hello');
});

What happens if fetchData() returns a promise resolving to 'hello'?

medium

A. The test fails because await is missing

B. The test passes because data matches 'hello'

C. The test throws a syntax error

D. The test never finishes because of missing done()

Solution

1. Step 1: Analyze async test behavior

   The test awaits fetchData(), so data gets the resolved value 'hello'.

2. Step 2: Check assertion correctness

   expect(data).toBe('hello') matches the resolved value, so the test passes.

3. Final Answer:

   The test passes because data matches 'hello' -> Option B

4. Quick Check:

   await resolves promise, expect matches value [OK]

Hint: Await resolves promise before expect check [OK]

Common Mistakes:

• Forgetting await causing test to fail
• Confusing syntax error with runtime error
• Thinking done() is needed with async/await

4. What is wrong with this async test code?

test('async error test', async () => {
  try {
    await asyncFunc();
  } catch (e) {
    expect(e.message).toBe('fail');
  }
});

medium

A. The test passes even if asyncFunc does not throw an error

B. The test syntax is invalid

C. The catch block will never run

D. The test needs done() callback

Solution

1. Step 1: Understand test behavior on no error

   If asyncFunc() does not throw, the catch block is skipped and no assertion runs.

2. Step 2: Consequence of missing assertion on success

   Test passes silently even if error was expected, missing failure detection.

3. Final Answer:

   The test passes even if asyncFunc does not throw an error -> Option A

4. Quick Check:

   Missing assertion outside catch causes false pass [OK]

Hint: Always assert outside catch to catch missing errors [OK]

Common Mistakes:

• Assuming catch always runs
• Not failing test if no error thrown
• Using done() unnecessarily with async/await

5. You want to test an async function getUser(id) that returns user data or throws if user not found. Which test correctly checks both success and error cases?

hard

A. test('user found', async () => {
const user = await getUser(1);
expect(user.name).toBe('Alice');
});
test('user not found', async () => {
try {
await getUser(999);
expect(true).toBe(false);
} catch (e) {
expect(e.message).toBe('not found');
}
});

B. test('user found', () => {
getUser(1).then(user => {
expect(user.name).toBe('Alice');
});
});
test('user not found', () => {
getUser(999).catch(e => {
expect(e.message).toBe('not found');
});
});

C. test('user found', async () => {
const user = getUser(1);
expect(user.name).toBe('Alice');
});
test('user not found', async () => {
try {
await getUser(999);
} catch (e) {
expect(e.message).toBe('not found');
}
});

D. test('user found', async () => {
const user = await getUser(1);
expect(user.name).toBe('Alice');
});
test('user not found', async () => {
expect(await getUser(999)).toThrow('not found');
});

Solution

1. Step 1: Check success test correctness

   Options A and D await getUser(1) and check user.name correctly. test('user found', async () => { const user = getUser(1); expect(user.name).toBe('Alice'); }); test('user not found', async () => { try { await getUser(999); } catch (e) { expect(e.message).toBe('not found'); } }); misses await, so user is a promise with no name property. test('user found', () => { getUser(1).then(user => { expect(user.name).toBe('Alice'); }); }); test('user not found', () => { getUser(999).catch(e => { expect(e.message).toBe('not found'); }); }); uses .then without async test function, risking timing issues.

2. Step 2: Check error test correctness

   test('user found', async () => { const user = await getUser(1); expect(user.name).toBe('Alice'); }); test('user not found', async () => { try { await getUser(999); expect(true).toBe(false); } catch (e) { expect(e.message).toBe('not found'); } }); correctly fails test if no error thrown by asserting false after await. test('user found', async () => { const user = await getUser(1); expect(user.name).toBe('Alice'); }); test('user not found', async () => { expect(await getUser(999)).toThrow('not found'); }); incorrectly awaits before expect.toThrow: rejection throws synchronously before expect runs; resolution uses wrong matcher on user object. test('user found', async () => { const user = getUser(1); expect(user.name).toBe('Alice'); }); test('user not found', async () => { try { await getUser(999); } catch (e) { expect(e.message).toBe('not found'); } }); misses failing test if no error thrown. test('user found', () => { getUser(1).then(user => { expect(user.name).toBe('Alice'); }); }); test('user not found', () => { getUser(999).catch(e => { expect(e.message).toBe('not found'); }); }); uses catch but no async/await, risking false positives.

3. Final Answer:

   Uses try { await getUser(999); expect(true).toBe(false); } catch (e) { expect(e.message).toBe('not found'); } -> Option A

4. Quick Check:

   Fail test if no error thrown in catch [OK]

Hint: Fail test explicitly if expected error is not thrown [OK]

Common Mistakes:

• Not awaiting promises in tests
• Missing failure assertion if no error thrown
• Using then/catch without async/await in Jest