Middleware testing strategies in Express - Step-by-Step Execution

Concept Flow - Middleware testing strategies

Write Middleware Function

↓

Create Mock Request & Response

↓

Call Middleware with Mocks

↓

Check Middleware Behavior

↓

Assert Expected Outcome

↓

Done

This flow shows how to test middleware by creating fake requests and responses, running the middleware, and checking results.

Execution Sample

Express

const req = { headers: { authorization: 'token' } };
const res = {};
const next = jest.fn();
middleware(req, res, next);
expect(next).toHaveBeenCalled();

This code tests a middleware by simulating a request, response, and next function, then checks if next() was called.

Execution Table

Step	Action	Input State	Middleware Behavior	Output State	Test Check
1	Create mock req	No req	Prepare req with headers.authorization='token'	req.headers.authorization='token'	N/A
2	Create mock res	No res	Prepare empty res object	res={}	N/A
3	Create mock next	No next	Create spy function to track calls	next=spy function	N/A
4	Call middleware(req,res,next)	req.headers.authorization='token', res={}, next=spy	Middleware checks authorization header, calls next()	next called once	N/A
5	Assert next called	next called once	Test framework verifies next() was called	Test passes	next() was called as expected
6	End	Test complete	No more actions	Test ends	Test successful

💡 Middleware calls next(), test confirms next() was called, so test ends successfully.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
req	undefined	{ headers: { authorization: 'token' } }	{ headers: { authorization: 'token' } }	{ headers: { authorization: 'token' } }	{ headers: { authorization: 'token' } }	{ headers: { authorization: 'token' } }
res	undefined	undefined	{}	{}	{}	{}
next	undefined	undefined	undefined	spy function	spy function (called once)	spy function (called once)

Key Moments - 3 Insights

Why do we create mock request and response objects instead of real ones?

Because real HTTP requests and responses are complex and slow to create, mocks let us test middleware quickly and control inputs precisely, as shown in execution_table steps 1 and 2.

How do we know if the middleware behaved correctly?

We check if the middleware called next() or modified res as expected. In the execution_table step 5, the test asserts next() was called, confirming correct behavior.

What if middleware sends a response and does not call next()?

Then the test should check if res methods like res.send were called and next() was not called. This differs from the example where next() is expected, as seen in execution_table step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of req.headers.authorization after Step 1?

A null

B 'token'

C undefined

D 'authorization'

💡 Hint

Check the 'Output State' column in Step 1 of execution_table.

At which step does the middleware call the next() function?

A Step 2

B Step 5

C Step 4

D Step 3

💡 Hint

Look at the 'Middleware Behavior' column to see when next() is called.

If the middleware did not call next(), which test check would fail according to the execution_table?

A Step 5 assertion

B Step 4 behavior

C Step 1 assertion

D Step 3 mock creation

💡 Hint

Step 5 asserts next() was called; if not, this assertion fails.

Concept Snapshot

Middleware testing steps:
1. Create mock req, res, next.
2. Call middleware(req, res, next).
3. Check if middleware calls next() or modifies res.
4. Assert expected behavior with test framework.
Use mocks to isolate middleware logic from real HTTP.
This ensures fast, reliable tests.

Full Transcript

Middleware testing in Express involves creating fake request and response objects and a spy function for next. We run the middleware with these mocks and check if it behaves as expected, such as calling next() or sending a response. This method isolates middleware logic from real network calls, making tests fast and reliable. The execution table shows each step from mock creation to assertion. Key points include why mocks are used, how to verify middleware behavior, and handling cases where middleware ends the response without calling next.