Testing async code in Node.js

Introduction

Testing async code helps make sure your program works correctly when doing tasks that take time, like reading files or fetching data from the internet.

When you want to check if a function that waits for data returns the right result.

When you need to test code that uses timers or delays.

When your code calls APIs or databases and you want to verify the responses.

When you want to catch errors that happen during asynchronous operations.

When you want to make sure your async code runs in the right order.

Syntax

Node.js

test('description', async () => {
  const result = await asyncFunction();
  expect(result).toBe(expectedValue);
});

Use async before the test function to write asynchronous tests.

Use await to wait for the async operation to finish before checking results.

Examples

This test waits for fetchData to finish and checks if the returned object has an id property.

Node.js

test('fetches data successfully', async () => {
  const data = await fetchData();
  expect(data).toHaveProperty('id');
});

This test checks if the async function throws an error when given bad input.

Node.js

test('throws error on bad input', async () => {
  await expect(asyncFunction('bad')).rejects.toThrow('Invalid input');
});

This test waits for a delay function and checks if at least 1 second passed.

Node.js

test('delays for 1 second', async () => {
  const start = Date.now();
  await delay(1000);
  const end = Date.now();
  expect(end - start).toBeGreaterThanOrEqual(1000);
});

Sample Program

This test checks that fetchData returns an object with the correct properties after waiting 500 milliseconds.

Node.js

import { test, expect } from '@jest/globals';

function fetchData() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ id: 1, name: 'Test' });
    }, 500);
  });
}

test('fetchData returns object with id', async () => {
  const data = await fetchData();
  expect(data).toHaveProperty('id');
  expect(data.id).toBe(1);
  expect(data.name).toBe('Test');
});

Important Notes

Always use await with async functions in tests to avoid false positives.

Use rejects to test for errors in async functions.

Keep async tests fast by avoiding unnecessary delays.

Summary

Async tests use async and await to handle waiting.

Use expect to check results after async calls.

Test both success and error cases for async code.

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