Node.js Backend Development Bootcamp · 课时

集成测试 API 端点

实施集成测试，验证不同组件之间的交互并确保 API 功能正常。

集成测试 API 端点 是 CoddyKit 上的免费 Node.js Backend Development Bootcamp 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Node.js Backend Development Bootcamp 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Node.js Backend Development Bootcamp 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

What is Integration Testing?

Welcome! In this lesson, we'll dive into integration testing for Node.js API endpoints. Unlike unit tests (which test small, isolated pieces of code), integration tests verify that different parts of your application work together as expected.

For APIs, this means ensuring your endpoints correctly handle requests, interact with databases or other services, and return the right responses.

Why Test API Endpoints?

Your API is the main way external clients interact with your backend. Robust integration tests ensure:

Endpoints respond with correct HTTP status codes.
Data sent to the API is processed and stored properly.
The API returns expected data formats (e.g., JSON).
Different components (like routing, middleware, database) integrate seamlessly.

This helps catch bugs early that unit tests might miss.

Essential Testing Tools

To test our Node.js API endpoints, we'll use a couple of key tools:

Jest: Our test runner and assertion library (introduced in Lesson 1).
Supertest: A library designed to test HTTP servers. It makes it easy to send requests and assert responses.
Express: Our web framework, for building the API itself.

Setting Up Supertest

First, let's install the necessary packages. We'll need express for our sample API, and jest and supertest for testing.

Run this command in your project terminal:

npm install --save-dev express jest supertest

Our Simple Express App

Let's create a basic Express application that we can test. We'll define a few simple routes.

Notice we export the app instance, which Supertest will use to make requests directly, without needing to start a live server on a port.

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

// Middleware to parse JSON request bodies
app.use(express.json());

// A simple GET route
app.get('/', (req, res) => {
  res.send('Hello from Express!');
});

// A GET route that returns JSON
app.get('/data', (req, res) => {
  res.json({ message: 'API data', version: 1.0 });
});

// A POST route that echoes the request body
app.post('/echo', (req, res) => {
  res.json(req.body);
});

// Export the app for testing purposes
module.exports = app;

// Start the server only if not in a test environment
if (process.env.NODE_ENV !== 'test') {
  const port = 3000;
  app.listen(port, () => {
    console.log(`Server running on port ${port}`);
  });
}

Testing a GET Endpoint

Now, let's write our first integration test. We'll use supertest to make a GET request to our root / endpoint and assert its response.

Create a file like app.test.js and add the following:

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

describe('GET /', () => {
  it('should return "Hello from Express!"', async () => {
    const res = await request(app).get('/');
    expect(res.statusCode).toEqual(200);
    expect(res.text).toEqual('Hello from Express!');
  });
});

Asserting JSON Responses

APIs often return JSON data. Supertest makes it easy to access the parsed JSON body of a response using res.body.

Let's test our /data endpoint to ensure it returns the correct JSON object:

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

describe('GET /data', () => {
  it('should return JSON with message and version', async () => {
    const res = await request(app).get('/data');
    expect(res.statusCode).toEqual(200);
    expect(res.type).toEqual('application/json');
    expect(res.body).toEqual({ message: 'API data', version: 1.0 });
    expect(res.body.message).toBe('API data');
  });
});

Testing POST Requests

Testing POST requests is similar, but we'll use .post() and often .send() to attach a request body.

Our /echo endpoint simply returns whatever JSON it receives. Let's test that functionality:

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

describe('POST /echo', () => {
  it('should echo the sent JSON data', async () => {
    const testData = { name: 'Coddy', score: 95 };
    const res = await request(app)
      .post('/echo')
      .send(testData);

    expect(res.statusCode).toEqual(200);
    expect(res.type).toEqual('application/json');
    expect(res.body).toEqual(testData);
  });
});

Database Interactions & Cleanup

When testing APIs that interact with a database, you typically:

Use a dedicated test database to prevent polluting your development data.
Clear the database before each test suite or test case (using beforeEach/afterEach hooks).
Seed data if specific data is needed for a test.

This ensures tests are independent and repeatable.

API Test Scenario

You're testing a Node.js API endpoint /users that accepts POST requests to create a new user. Which of the following statements are TRUE about integration testing this endpoint?

Recap: Integration Testing

Great job! You've learned the fundamentals of integration testing for Node.js API endpoints:

What it is: Verifying components work together, especially for API requests.
Tools: Using Supertest with Jest to simulate HTTP requests.
Method: Sending GET/POST requests and asserting status codes, body content, and data types.
Best Practices: Considering dedicated test databases for isolation.

This ensures your API is robust and reliable!

常见问题解答

「集成测试 API 端点」课时是免费的吗？

是的 — 「集成测试 API 端点」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Node.js Backend Development Bootcamp 课程的其余内容，请升级到 CoddyKit PRO。 Node.js Backend Development Bootcamp 课程共包含 4 节课。

「集成测试 API 端点」这节课中我会学到什么？

实施集成测试，验证不同组件之间的交互并确保 API 功能正常。你通过在浏览器中直接运行的动手代码来练习 Node.js Backend Development Bootcamp，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Node.js Backend Development Bootcamp 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Node.js Backend Development Bootcamp 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「集成测试 API 端点」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Node.js Backend Development Bootcamp 课中编写并运行代码吗？

能。每节 Node.js Backend Development Bootcamp 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Node.js Backend Development Bootcamp