Testing async code in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main challenge when testing asynchronous code?

The main challenge is ensuring the test waits for the async operation to complete before checking results, so tests don't finish too early and give false results.

beginner

How do you tell a test framework like Jest to wait for an async function to finish?

You can return a Promise, use async/await syntax, or use a callback like 'done' to signal when the async work is complete.

beginner

What does the 'async' keyword do in a test function?

It allows you to use 'await' inside the test, making the test wait for asynchronous code to finish before continuing.

intermediate

Why should you avoid mixing callbacks and Promises in async tests?

Mixing them can cause confusion and errors, like tests finishing before async code runs, leading to unreliable test results.

intermediate

How can you test that an async function throws an error?

Use 'await expect(asyncFunc()).rejects.toThrow()' in Jest to check that the Promise rejects with an error.

Which keyword allows you to pause a test until an async operation completes?

A await

B async

C return

D done

The 'await' keyword pauses the test until the Promise resolves or rejects.

In Jest, how do you signal that an async test using callbacks is finished?

A Use 'async' keyword

B Return a Promise

C Call the 'done' callback

D Use 'await' keyword

Calling 'done' tells Jest the async test is complete when using callbacks.

What happens if you forget to wait for an async function in a test?

A Test may pass or fail incorrectly because it finishes too early

B Test will always fail

C Test will run synchronously

D Test will throw a syntax error

Without waiting, the test may finish before async code runs, causing wrong results.

Which Jest syntax checks that an async function throws an error?

A await expect(fn()).toThrow()

B expect(fn()).toThrow()

C expect(fn()).resolves.toThrow()

D await expect(fn()).rejects.toThrow()

'rejects.toThrow()' is used to test rejected Promises with errors.

What is a good practice when writing async tests?

A Always use callbacks only

B Use async/await or return Promises, but avoid mixing callbacks and Promises

C Never use async/await

D Ignore async behavior in tests

Using async/await or returning Promises keeps tests clear and reliable.

Explain how to write a test for an asynchronous function using async/await in Node.js.

Think about how to pause the test until the async work finishes.

Describe how to test that an async function throws an error using Jest.

Focus on how Jest handles rejected Promises in tests.

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