Mocking database calls in Express - Step-by-Step Execution

Concept Flow - Mocking database calls

Start Express app

↓

Receive API request

↓

Call database function

↓

Mock intercepts call

↓

Return fake data

↓

Send response with fake data

↓

End request

This flow shows how an Express app receives a request, calls a database function, but the call is intercepted by a mock that returns fake data instead of real database results.

Execution Sample

Express

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

// Mock database function
const db = { getUser: () => ({ id: 1, name: 'Mock User' }) };

app.get('/user', (req, res) => {
  const user = db.getUser();
  res.json(user);
});

This code sets up an Express route that returns a mocked user object instead of calling a real database.

Execution Table

Step	Action	Function Called	Return Value	Response Sent
1	Receive GET /user request	N/A	N/A	N/A
2	Call db.getUser()	db.getUser()	{ id: 1, name: 'Mock User' }	N/A
3	Send JSON response	N/A	N/A	{ id: 1, name: 'Mock User' }
4	Request ends	N/A	N/A	N/A

💡 Request ends after sending mocked user data as JSON response

Variable Tracker

Variable	Start	After Step 2	Final
user	undefined	{ id: 1, name: 'Mock User' }	{ id: 1, name: 'Mock User' }

Key Moments - 2 Insights

Why does the app return a user object without connecting to a real database?

Because the db.getUser function is mocked to return a fixed object, as shown in execution_table step 2, so no real database call happens.

What happens if we remove the mock and call a real database function?

The app would try to connect to the database, which might delay response or fail if the database is unavailable. The mock avoids this by returning data immediately.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'user' after step 2?

A undefined

B { id: 1, name: 'Mock User' }

C null

D {}

💡 Hint

Check the variable_tracker table under 'After Step 2' for 'user'

At which step is the JSON response sent back to the client?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Response Sent' column in execution_table

If the mock was removed, what would change in the execution flow?

A The response would be sent before calling db.getUser

B The app would not receive the request

C db.getUser would call the real database instead of returning fake data

D The mock would still intercept the call

💡 Hint

Refer to key_moments about what happens without the mock

Concept Snapshot

Mocking database calls in Express:
- Replace real DB functions with fake ones returning fixed data
- Allows testing API routes without real DB
- Mocked functions return immediately
- Helps isolate backend logic from DB
- Use mocks during development and testing

Full Transcript

This example shows how an Express app handles a GET request to /user by calling a mocked database function. Instead of querying a real database, the mock returns a fixed user object immediately. The app then sends this mocked data as a JSON response. This approach helps developers test and develop APIs without needing a real database connection. The execution table traces each step: receiving the request, calling the mock, returning fake data, and sending the response. The variable tracker shows the user variable getting assigned the mocked data. Key moments clarify why mocking avoids real database calls and what changes if the mock is removed. The quiz tests understanding of the flow and variable states.

Practice

1. What is the main purpose of mocking database calls in Express applications?

easy

A. To test code without needing a real database connection

B. To speed up the database queries in production

C. To permanently replace the database with fake data

D. To make the database store data faster

Solution

1. Step 1: Understand mocking concept

   Mocking means creating fake versions of parts of your app, like database calls, to test without real dependencies.

2. Step 2: Identify the purpose in testing

   Mocking database calls allows testing code logic without needing a real database, making tests faster and more reliable.

3. Final Answer:

   To test code without needing a real database connection -> Option A

4. Quick Check:

   Mocking = Test without real DB [OK]

Hint: Mocking means faking DB calls to test code fast [OK]

Common Mistakes:

• Thinking mocking speeds up production DB
• Confusing mocking with permanent DB replacement
• Assuming mocking changes real data storage

2. Which of the following is the correct way to mock a database call returning a promise in Express?

easy

A. const mockDbCall = Promise.resolve({ id: 1, name: 'Test' });

B. const mockDbCall = () => { return { id: 1, name: 'Test' }; };

C. const mockDbCall = () => new Promise({ id: 1, name: 'Test' });

D. const mockDbCall = () => Promise.resolve({ id: 1, name: 'Test' });

Solution

1. Step 1: Understand promise returning function

   A mock database call should return a promise that resolves to data, so Promise.resolve is correct.

2. Step 2: Check each option

   const mockDbCall = Promise.resolve({ id: 1, name: 'Test' }); assigns a resolved promise directly, making mockDbCall a promise object not a callable function. const mockDbCall = () => { return { id: 1, name: 'Test' }; }; returns plain object, not a promise. const mockDbCall = () => Promise.resolve({ id: 1, name: 'Test' }); returns a function returning a resolved promise, correct. const mockDbCall = () => new Promise({ id: 1, name: 'Test' }); incorrectly uses new Promise without executor function.

3. Final Answer:

   const mockDbCall = () => Promise.resolve({ id: 1, name: 'Test' }); -> Option D

4. Quick Check:

   Promise.resolve returns a resolved promise [OK]

Hint: Use Promise.resolve to return mock data as a promise [OK]

Common Mistakes:

• Returning plain object instead of a promise
• Using new Promise without executor function
• Assigning a promise directly instead of a function returning it

3. Given the mock function below, what will getUser().then(console.log) output?

const getUser = () => Promise.resolve({ id: 5, name: 'Alice' });

medium

A. { id: 5, name: 'Alice' }

B. Promise { { id: 5, name: 'Alice' } }

C. undefined

D. Error: getUser is not a function

Solution

1. Step 1: Understand the mock function

   getUser returns a promise resolved with an object { id: 5, name: 'Alice' }.

2. Step 2: Analyze the .then(console.log) call

   The .then method receives the resolved value and logs it, so the output is the object itself.

3. Final Answer:

   { id: 5, name: 'Alice' } -> Option A

4. Quick Check:

   Promise resolves to object logged [OK]

Hint: Promise.then logs resolved value, not the promise itself [OK]

Common Mistakes:

• Thinking console.log prints the promise object
• Expecting undefined because of missing await
• Assuming getUser is undefined or error

4. Identify the error in this mock database call function:

function fetchData() {
  return new Promise(data => {
    resolve({ id: 1, value: 'mock' });
  });
}

medium

A. The function should be async instead of returning a promise

B. The promise executor function parameter should be (resolve, reject), not (data)

C. The data object is missing a required field

D. The function should not return a promise

Solution

1. Step 1: Review Promise constructor usage

   The Promise constructor expects an executor function with two parameters: resolve and reject.

2. Step 2: Identify misuse of parameter

   The code declares executor parameter as 'data' but calls resolve(...), where resolve is undefined. It should declare (resolve, reject) and call resolve(value).

3. Final Answer:

   The promise executor function parameter should be (resolve, reject), not (data) -> Option B

4. Quick Check:

   Promise executor = (resolve, reject) [OK]

Hint: Promise executor needs (resolve, reject) parameters [OK]

Common Mistakes:

• Using wrong parameter name in Promise executor
• Not returning a promise for async behavior
• Confusing async function with Promise constructor

5. You want to mock a database call in Express that sometimes returns data and sometimes throws an error to test error handling. Which mock function correctly simulates this behavior?

hard

A. const mockDb = () => Promise.resolve({ id: 1 });

B. const mockDb = () => { if (Math.random() > 0.5) return { id: 1 }; else throw new Error('DB error'); };

C. const mockDb = () => Math.random() > 0.5 ? Promise.resolve({ id: 1 }) : Promise.reject(new Error('DB error'));

D. const mockDb = () => new Promise((resolve) => resolve({ id: 1 }));

Solution

1. Step 1: Understand requirement for success and failure

   The mock must sometimes resolve with data and sometimes reject with an error to test both cases.

2. Step 2: Analyze each option

   const mockDb = () => Math.random() > 0.5 ? Promise.resolve({ id: 1 }) : Promise.reject(new Error('DB error')); returns a promise that resolves or rejects based on random chance, correctly simulating success or failure.
   const mockDb = () => { if (Math.random() > 0.5) return { id: 1 }; else throw new Error('DB error'); }; throws error synchronously, not returning a promise rejection.
   const mockDb = () => Promise.resolve({ id: 1 }); always resolves, no error simulation.
   const mockDb = () => new Promise((resolve) => resolve({ id: 1 })); always resolves, no error simulation.

3. Final Answer:

   const mockDb = () => Math.random() > 0.5 ? Promise.resolve({ id: 1 }) : Promise.reject(new Error('DB error')); -> Option C

4. Quick Check:

   Random resolve or reject simulates success/error [OK]

Hint: Use Promise.resolve or Promise.reject to simulate success or error [OK]

Common Mistakes:

• Throwing error instead of rejecting promise
• Always resolving without error case
• Not returning a promise for async simulation