Writing test cases in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Jest test case?

Consider this simple function and its test case. What will be the test result when running Jest?

Node.js

function add(a, b) {
  return a + b;
}

test('adds 2 + 3 to equal 5', () => {
  expect(add(2, 3)).toBe(5);
});

A Test fails because add returns undefined

B Test fails with a type error

C Test throws a syntax error

D Test passes successfully

💡 Hint

Look at what the add function returns and what the test expects.

The add function returns the sum of 2 and 3, which is 5. The test expects 5, so it passes.

📝 Syntax

intermediate

Which Jest test case has a syntax error?

Identify the test case that will cause a syntax error when running Jest.

A test('missing closing parenthesis', () => { expect(1).toBe(1);

B test('checks true is true', () => { expect(true).toBe(true); });

C test('checks false is false', () => { expect(false).toBe(false); });

D test('checks null is null', () => { expect(null).toBe(null); });

💡 Hint

Look for missing brackets or parentheses.

Option A is missing the closing parenthesis and curly brace, causing a syntax error.

🔧 Debug

advanced

Why does this Jest test fail?

Given the following code, why does the test fail?

Node.js

function multiply(a, b) {
  return a * b;
}

test('multiply 2 and 3 equals 5', () => {
  expect(multiply(2, 3)).toBe(5);
});

A The test fails due to a syntax error in the test case

B The test fails because multiply is not defined

C The test fails because multiply(2, 3) returns 6, not 5

D The test fails because toBe is not a valid matcher

💡 Hint

Check the expected value versus the actual function output.

multiply(2, 3) returns 6, but the test expects 5, so it fails.

❓ state_output

advanced

What is the value of 'result' after this Jest test runs?

Consider this test case with a variable 'result'. What is its value after the test completes?

Node.js

let result = 0;
function increment() {
  result += 1;
}

test('increment increases result', () => {
  increment();
  expect(result).toBe(1);
});

A result is 1

B result is 0

C result is undefined

D result is NaN

💡 Hint

Look at how the increment function changes result.

The increment function adds 1 to result, so after calling it once, result is 1.

🧠 Conceptual

expert

Which Jest test case correctly tests an async function?

Given an async function fetchData that returns a promise resolving to 'data', which test case correctly waits for the promise to resolve?

Node.js

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

A

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

B

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

C

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

D

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

💡 Hint

Think about how to wait for async code in Jest tests.

Option B uses async/await properly to wait for fetchData to resolve before asserting.