Jest or Vitest setup for Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Jest test for an Express route?

Consider this Express app and Jest test. What will the test output?

Express

const express = require('express');
const request = require('supertest');

const app = express();
app.get('/hello', (req, res) => {
  res.status(200).send('Hello World');
});

test('GET /hello returns Hello World', async () => {
  const response = await request(app).get('/hello');
  return response.text;
});

A TypeError

B "hello world"

C "Hello World"

D undefined

💡 Hint

Check the exact string sent by the Express route.

The Express route sends 'Hello World' with capital H and W. The test returns response.text which matches exactly.

📝 Syntax

intermediate

Which Vitest setup code correctly mocks an Express middleware?

Choose the correct Vitest code snippet to mock an Express middleware function.

A

import { vi } from 'vitest';
const mockMiddleware = vi.fn((req, res, next) => next());

B const mockMiddleware = jest.fn((req, res, next) => next());

C

import { mock } from 'vitest';
const mockMiddleware = mock((req, res, next) => next());

D

import { spy } from 'vitest';
const mockMiddleware = spy((req, res, next) => next());

💡 Hint

Vitest uses vi.fn to create mocks.

Vitest's mocking function is vi.fn. Options B and D use non-existent imports. Option A uses Jest syntax, not Vitest.

🔧 Debug

advanced

Why does this Jest test for an Express async route fail with timeout?

Look at this Jest test for an async Express route. Why does it fail with a timeout?

Express

const express = require('express');
const request = require('supertest');

const app = express();
app.get('/data', async (req, res) => {
  await new Promise(resolve => setTimeout(resolve, 100));
  res.json({ success: true });
});

test('GET /data returns success true', () => {
  return request(app).get('/data').expect(200).expect('Content-Type', /json/).expect({ success: true });
});

A The test lacks async/await or returning the promise, so Jest finishes before response.

B The Express route does not call next(), causing the request to hang.

C The test expects wrong status code 200 instead of 201.

D The test uses .expect with an object which is invalid syntax.

💡 Hint

Check how Jest knows when async tests finish.

The test function is not marked async and does not return the promise from supertest, so Jest ends the test early causing timeout.

❓ state_output

advanced

What is the value of 'count' after this Vitest test runs?

Given this Express app and Vitest test, what is the final value of the variable count?

Express

import express from 'express';
import request from 'supertest';
import { describe, it, expect } from 'vitest';

let count = 0;
const app = express();
app.get('/increment', (req, res) => {
  count += 1;
  res.send('ok');
});

describe('Increment route', () => {
  it('increments count twice', async () => {
    await request(app).get('/increment');
    await request(app).get('/increment');
  });
});

A undefined

B 0

C 1

D 2

💡 Hint

Each GET request to /increment adds 1 to count.

The test calls the route twice, each time increasing count by 1, so final count is 2.

🧠 Conceptual

expert

Which option correctly explains why Vitest can run Express tests faster than Jest?

Vitest is often faster than Jest for testing Express apps. Why?

A Vitest compiles Express code to native binaries before testing.

B Vitest runs tests in the same process without spawning workers, reducing overhead.

C Vitest uses a slower but more accurate virtual DOM for Express testing.

D Vitest disables all asynchronous code to speed up tests.

💡 Hint

Think about how test runners handle processes and workers.

Vitest runs tests in the same process by default, avoiding worker startup time, making it faster especially for small test suites.