Testing async code in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this async test with Jest?

Consider this Jest test code that tests an async function. What will the test output be?

Node.js

test('async test with done callback', done => {
  setTimeout(() => {
    expect(2 + 2).toBe(4);
    done();
  }, 100);
});

A The test times out because done() is never called.

B The test fails immediately due to missing await.

C The test passes after 100ms delay.

D The test throws a syntax error.

💡 Hint

Look at how done() is used to signal test completion.

The test uses the done callback correctly. The assertion runs after 100ms, then done() signals Jest to finish the test, so it passes.

📝 Syntax

intermediate

Which option correctly tests an async function returning a promise in Jest?

You want to test this async function that returns a promise. Which test code is correct?

Node.js

async function fetchData() {
  return 'data';
}

A

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

B

test('fetchData returns data', () => {
  const data = fetchData();
  expect(data).toBe('data');
});

C

test('fetchData returns data', () => {
  return fetchData().then(data => {
    expect(data).toBe('data');
  });
});

D

test('fetchData returns data', () => {
  expect(fetchData()).toBe('data');
});

💡 Hint

Remember to await the promise or return it for Jest to handle async.

Option A uses async/await correctly to wait for the promise to resolve before asserting.

🔧 Debug

advanced

Why does this Jest async test fail with a timeout?

Examine this test code. Why does Jest report a timeout error?

Node.js

test('async test missing return', () => {
  fetchData().then(data => {
    expect(data).toBe('data');
  });
});

async function fetchData() {
  return 'data';
}

A Because the test function is marked async but does not await.

B Because fetchData throws an error that is not caught.

C Because expect is used incorrectly inside then.

D Because the test function does not return the promise, Jest does not wait for it.

💡 Hint

Jest needs to know when async work finishes.

Jest requires the test to return the promise or use async/await to wait. Without returning, Jest finishes test immediately causing timeout.

❓ state_output

advanced

What is the value of count after this async test runs?

Given this code, what is the final value of count after the test completes?

Node.js

let count = 0;

function incrementAsync() {
  return new Promise(resolve => {
    setTimeout(() => {
      count += 1;
      resolve(count);
    }, 50);
  });
}

test('incrementAsync increments count', async () => {
  await incrementAsync();
  await incrementAsync();
});

A count is undefined

B count is 2

C count is 0

D count is 1

💡 Hint

Each call increments count by 1 after 50ms.

Each awaited call increments count by 1 sequentially, so after two calls count is 2.

🧠 Conceptual

expert

Which Jest test pattern ensures proper async error handling?

You want to test that an async function throws an error. Which test pattern correctly catches the error?

Node.js

async function failAsync() {
  throw new Error('fail');
}

A

test('failAsync throws', async () => {
  await expect(failAsync()).rejects.toThrow('fail');
});

B

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

C

test('failAsync throws', () => {
  expect(() => failAsync()).toThrow('fail');
});

D

test('failAsync throws', () => {
  return failAsync().catch(e => {
    expect(e.message).toBe('fail');
  });
});

💡 Hint

Use Jest's rejects matcher for promises that throw.

Option A uses Jest's built-in rejects matcher to properly test async errors. Others either miss returning or do not await properly.