Testing GET endpoints in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the response body of this GET endpoint?

Consider this Express GET endpoint. What will the client receive as the response body when requesting /hello?

Express

const express = require('express');
const app = express();

app.get('/hello', (req, res) => {
  res.json({ message: 'Hello, world!' });
});

A {"message":"Hello, world!"}

B "Hello, world!"

C {"msg":"Hello, world!"}

D Status 404 Not Found

💡 Hint

Look at the method used to send the response and the object passed.

The endpoint uses res.json() to send a JSON object with a key 'message' and value 'Hello, world!'. So the client receives {"message":"Hello, world!"}.

📝 Syntax

intermediate

Which option correctly defines a GET endpoint that sends plain text?

Which code snippet correctly defines a GET endpoint at /text that sends the plain text response "Hello"?

A app.get('/text', (req, res) => { res.json('Hello'); });

B app.get('/text', (req, res) => { res.sendJson('Hello'); });

C app.get('/text', (req, res) => { res.send('Hello'); });

D app.get('/text', (req, res) => { res.sendText('Hello'); });

💡 Hint

Check the Express method that sends plain text responses.

res.send() sends plain text or HTML. res.json() sends JSON. res.sendJson and res.sendText are not valid Express methods.

🔧 Debug

advanced

Why does this GET endpoint cause a runtime error?

Examine the code below. Why will a GET request to /data cause a runtime error?

Express

app.get('/data', (req, res) => {
  const data = undefined;
  res.json(data.value);
});

A TypeError because data is undefined and accessing data.value fails

B ReferenceError because res is not defined

C SyntaxError due to missing semicolon

D No error, response is null

💡 Hint

What happens if you try to access a property of undefined?

Accessing a property on undefined causes a TypeError at runtime.

❓ state_output

advanced

What is the response after multiple GET requests?

Given this Express app, what will be the response body of the third GET request to /count?

Express

let count = 0;
app.get('/count', (req, res) => {
  count += 1;
  res.json({ count });
});

A {"count":2}

B {"count":1}

C {"count":0}

D {"count":3}

💡 Hint

The variable count increases by 1 on each request.

Each GET request increments count by 1. On the third request, count is 3.

🧠 Conceptual

expert

Which option correctly explains why this GET endpoint never sends a response?

Consider this Express GET endpoint. Why does a client request to /never hang indefinitely?

Express

app.get('/never', (req, res) => {
  if (false) {
    res.send('Done');
  }
  // no else or res.send outside if
});

A Because the if condition is false, res.send throws an error

B Because res.send is never called, the server never ends the response, causing the client to wait forever

C Because Express requires res.json instead of res.send

D Because the route path is invalid and Express ignores the handler

💡 Hint

Think about what happens if no response method is called in Express.

If no response method like res.send or res.end is called, the client waits forever because the server never finishes the response.

Practice

1. What is the main purpose of testing GET endpoints in an Express app?

easy

A. To verify the server returns the correct data and status code

B. To check if the server can handle POST requests

C. To test database connection speed

D. To validate CSS styles on the page

Solution

1. Step 1: Understand GET endpoint testing

   Testing GET endpoints means checking if the server responds correctly when a client asks for data.

2. Step 2: Identify the goal of testing

   The goal is to confirm the server sends the right data and proper HTTP status code (like 200 for success).

3. Final Answer:

   To verify the server returns the correct data and status code -> Option A

4. Quick Check:

   Testing GET endpoints = verify data and status [OK]

Hint: GET endpoint tests check response data and status code [OK]

Common Mistakes:

• Confusing GET with POST request testing
• Testing unrelated features like CSS or database speed
• Ignoring status codes in tests

2. Which of the following is the correct way to start a test for a GET endpoint using supertest with Express?

easy

A. app.get('/path').send(200);

B. request(app).get('/path').expect(200, done);

C. supertest.get('/path').expect(200);

D. request.get(app, '/path').expect(200);

Solution

1. Step 1: Recall supertest syntax

   Supertest uses request(app).get('/path') to simulate a GET request to the Express app.

2. Step 2: Check the correct chaining

   Chaining .expect(200, done) checks the status code and signals test completion.

3. Final Answer:

   request(app).get('/path').expect(200, done); -> Option B

4. Quick Check:

   supertest GET syntax = request(app).get(path).expect(status) [OK]

Hint: Use request(app).get(path).expect(status, done) for GET tests [OK]

Common Mistakes:

• Calling app.get() instead of request(app).get()
• Missing the done callback in async tests
• Incorrect method chaining order

3. Given this Express GET endpoint and test code, what will the test output?

const express = require('express');
const app = express();
app.get('/hello', (req, res) => res.json({ message: 'Hi!' }));

const request = require('supertest');

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

medium

A. "Hi!"

B. undefined

C. Error: No response

D. "hello"

Solution

1. Step 1: Analyze the endpoint response

   The GET /hello endpoint sends JSON { message: 'Hi!' } as response.

2. Step 2: Check the test return value

   The test awaits the GET request and returns response.body.message, which is 'Hi!'.

3. Final Answer:

   "Hi!" -> Option A

4. Quick Check:

   GET /hello returns message = "Hi!" [OK]

Hint: Response body message matches endpoint JSON key [OK]

Common Mistakes:

• Expecting response.body instead of response.body.message
• Forgetting to await the request
• Assuming string 'hello' instead of 'Hi!'

4. Identify the error in this test code for an Express GET endpoint:

const request = require('supertest');
const app = require('./app');

test('GET /users returns 200', () => {
  request(app)
    .get('/users')
    .expect(200);
});

medium

A. Missing import of Express

B. Incorrect HTTP method used

C. Missing return or await to handle async test

D. Wrong path '/users' does not exist

Solution

1. Step 1: Check async test handling

   The test function is async but does not return or await the request promise, so Jest won't wait for it.

2. Step 2: Confirm correct fix

   Adding return before request(...) or making the test async and awaiting fixes the issue.

3. Final Answer:

   Missing return or await to handle async test -> Option C

4. Quick Check:

   Async test needs return or await [OK]

Hint: Always return or await supertest calls in tests [OK]

Common Mistakes:

• Not returning or awaiting async calls in tests
• Assuming path or method is wrong without checking
• Confusing import errors with test async errors

5. You want to test an Express GET endpoint that returns a list of users, but only those with active status true. Which test code correctly checks this filtering?

app.get('/active-users', (req, res) => {
  const users = [
    { id: 1, active: true },
    { id: 2, active: false },
    { id: 3, active: true }
  ];
  res.json(users.filter(u => u.active));
});

// Test code options:
A) await request(app).get('/active-users').expect(200).expect(res => {
  if (!res.body.every(u => u.active)) throw new Error('Inactive user found');
});

B) await request(app).get('/active-users').expect(200).expect(res => {
  if (res.body.length !== 3) throw new Error('Wrong number of users');
});

C) await request(app).get('/active-users').expect(404);

D) await request(app).get('/active-users').expect(200).expect(res => {
  if (!res.body.some(u => u.active === false)) throw new Error('Inactive user found');
});

hard

A. Incorrectly throws error when no inactive users found

B. Incorrectly expects all users, including inactive

C. Wrong status code expectation

D. Checks for inactive users but throws error if found

Solution

1. Step 1: Understand endpoint filtering

   The endpoint returns only users with active: true, so no inactive users should appear.

2. Step 2: Analyze test options

   Checks for inactive users but throws error if found uses every(u => u.active) and throws if any inactive, correctly verifying the filter.
   Incorrectly expects all users, including inactive expects length !== 3 (wrong, it's 2).
   Wrong status code expectation expects 404 (wrong).
   Incorrectly throws error when no inactive users found incorrectly throws error when no inactive users found.

3. Step 3: Verify A logic

   !every(u => u.active) detects any inactive user, matching the requirement.

4. Final Answer:

   Checks for inactive users but throws error if found -> Option D

5. Quick Check:

   Test filters out inactive users = no inactive found [OK]

Hint: Check response has no inactive users with some() or every() [OK]

Common Mistakes:

• Expecting all users instead of filtered active only
• Using wrong status code in test
• Confusing every() and some() logic in tests