Integration vs unit test decision in Express - Visual Side-by-Side Comparison

Concept Flow - Integration vs unit test decision

Write Code

↓

Choose Test Type

↓

Unit Test

↓

Test Small

↓

Parts Only

↓

Fast, Isolated

↓

Mock Dependencies

↓

Decide Based on Need

↓

Run Tests & Fix Code

This flow shows how to decide between unit and integration tests by considering scope, speed, and dependencies.

Execution Sample

Express

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

test('GET /users returns list', async () => {
  const res = await request(app).get('/users');
  expect(res.statusCode).toBe(200);
});

This code runs an integration test on the /users route of an Express app to check if it returns status 200.

Execution Table

Step	Test Type	Scope	Dependencies	Speed	Outcome
1	Unit Test	Single function/module	Mocks used	Fast	Isolated check
2	Integration Test	Multiple modules/routes	Real dependencies	Slower	Realistic check
3	Decision Point	Based on need	Mocks or real	Depends	Choose test type
4	Run Tests	Selected scope	Mocks or real	Varies	Pass or fail
5	Fix Code	Based on test	N/A	N/A	Improve code quality
6	Exit	All tests done	N/A	N/A	Confidence in code

💡 All tests complete, code quality verified or improved

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Test Type	None	Unit Test	Integration Test	Chosen based on need	Final test type selected
Scope	None	Single function/module	Multiple modules/routes	Decided by test type	Test scope set
Dependencies	None	Mocks used	Real dependencies	Depends on test	Dependencies set
Speed	None	Fast	Slower	Depends on test	Test speed noted
Outcome	None	Isolated check	Realistic check	Test results	Pass or fail

Key Moments - 3 Insights

Why do unit tests use mocks instead of real dependencies?

Unit tests focus on one part only, so mocks replace other parts to keep tests fast and isolated, as shown in execution_table step 1.

When should I choose integration tests over unit tests?

Choose integration tests when you want to check how parts work together with real dependencies, as shown in execution_table step 2 and 3.

Does running integration tests always take longer?

Yes, because integration tests use real dependencies and cover more code, making them slower than unit tests (execution_table step 2).

Visual Quiz - 3 Questions

Look at the execution_table, what is the 'Speed' value for unit tests at step 1?

A Slower

B Fast

C Depends

D None

💡 Hint

Check the 'Speed' column in row with Step 1 in execution_table.

At which step in the execution_table do you decide which test type to use?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for the row labeled 'Decision Point' in execution_table.

According to variable_tracker, what is the 'Dependencies' value after Step 2?

A Real

B None

C Mocks

D Depends

💡 Hint

Check the 'Dependencies' row under 'After Step 2' column in variable_tracker.

Concept Snapshot

Integration vs Unit Test Decision

- Unit tests check one part only, using mocks for dependencies.
- Integration tests check multiple parts working together with real dependencies.
- Unit tests are fast and isolated; integration tests are slower but realistic.
- Choose test type based on what you want to verify.
- Run tests to find and fix bugs early.

Full Transcript

This visual execution shows how to decide between unit and integration tests in Express. First, write your code. Then choose test type: unit tests focus on single parts using mocks, making them fast and isolated. Integration tests check multiple parts together with real dependencies, so they are slower but more realistic. The execution table shows steps from choosing test type to running tests and fixing code. The variable tracker follows how test type, scope, dependencies, speed, and outcomes change through steps. Key moments clarify why mocks are used in unit tests, when to pick integration tests, and why integration tests take longer. The quiz tests understanding of speed, decision steps, and dependencies. This helps beginners see the practical flow of testing decisions in Express apps.

Practice

1. Which type of test in Express focuses on checking a single function or module in isolation?

easy

A. Unit test

B. Integration test

C. End-to-end test

D. Performance test

Solution

1. Step 1: Understand test types in Express

   Unit tests focus on small pieces like functions or modules alone, without dependencies.

2. Step 2: Identify test purpose

   Integration tests check how parts work together, so they are not isolated.

3. Final Answer:

   Unit test -> Option A

4. Quick Check:

   Single module check = Unit test [OK]

Hint: Unit tests isolate one part; integration tests combine parts [OK]

Common Mistakes:

• Confusing integration tests with unit tests
• Thinking end-to-end tests are unit tests
• Assuming performance tests check single functions

2. Which of the following is the correct way to write a simple unit test for an Express middleware function?

easy

A. Use a browser to manually check middleware behavior

B. Test the middleware by calling it with mock request and response objects

C. Start the Express server and send HTTP requests to test the middleware

D. Run the entire app and check logs for middleware output

Solution

1. Step 1: Understand unit test scope

   Unit tests isolate the middleware by calling it directly with mock objects, no server needed.

2. Step 2: Identify correct testing method

   Starting the server or manual checks are integration or manual tests, not unit tests.

3. Final Answer:

   Test the middleware by calling it with mock request and response objects -> Option B

4. Quick Check:

   Mock objects for unit test [OK]

Hint: Unit test = call function with mocks, no server start [OK]

Common Mistakes:

• Starting server for unit tests
• Using manual browser checks for unit tests
• Confusing integration test methods with unit tests

3. Consider this Express test snippet:

request(app)
  .get('/users')
  .expect(200)
  .end((err, res) => {
    if (err) throw err;
    console.log(res.body.length);
  });

What type of test is this and what does it check?

medium

A. Unit test; mocks the database call

B. Unit test; checks a single function's return value

C. Integration test; checks the route and middleware working together

D. Performance test; measures response time

Solution

1. Step 1: Analyze the test code

   The test sends an HTTP GET request to '/users' on the app, expecting status 200.

2. Step 2: Identify test type

   This checks the route handler and middleware together, so it's an integration test.

3. Final Answer:

   Integration test; checks the route and middleware working together -> Option C

4. Quick Check:

   HTTP request test = Integration test [OK]

Hint: HTTP request tests check multiple parts together [OK]

Common Mistakes:

• Calling this a unit test
• Assuming it mocks database calls
• Thinking it measures performance

4. You wrote a test that starts the Express server and sends HTTP requests, but it runs very slowly and sometimes fails due to timing issues. What is the best way to fix this problem?

medium

A. Rewrite the test as a unit test using mocks instead of starting the server

B. Add more delays in the test to wait for responses

C. Increase server timeout settings in Express

D. Run the test on a faster machine

Solution

1. Step 1: Identify the problem cause

   Starting the server and sending real HTTP requests makes tests slow and flaky.

2. Step 2: Choose a better testing approach

   Using unit tests with mocks avoids server start and speeds up tests, reducing timing issues.

3. Final Answer:

   Rewrite the test as a unit test using mocks instead of starting the server -> Option A

4. Quick Check:

   Mocks speed tests, avoid server start [OK]

Hint: Mocks speed tests; avoid real server start [OK]

Common Mistakes:

• Adding delays instead of fixing test design
• Changing server settings unnecessarily
• Blaming hardware instead of test approach

5. You want to test an Express app's user login flow. Which approach best balances speed and coverage by combining unit and integration tests?

hard

A. Only write integration tests for the login route to cover everything at once

B. Test manually in the browser without automated tests

C. Write unit tests for the entire Express app without any integration tests

D. Write unit tests for the login function logic and integration tests for the full login route with database

Solution

1. Step 1: Understand testing goals

   Unit tests check small parts fast; integration tests check how parts work together.

2. Step 2: Combine tests for best results

   Writing unit tests for login logic and integration tests for the route with database balances speed and coverage.

3. Final Answer:

   Write unit tests for the login function logic and integration tests for the full login route with database -> Option D

4. Quick Check:

   Combine unit + integration tests for best coverage [OK]

Hint: Use unit tests for logic, integration for routes [OK]

Common Mistakes:

• Relying only on integration tests
• Skipping integration tests entirely
• Ignoring automated tests in favor of manual