Ujian unit untuk NodeJS menggunakan Mocha dan Chai

Ujian unit adalah penting kerana ia menyemak bahagian kecil kod untuk memastikan ia berfungsi dengan betul dan menemui pepijat lebih awal. Adalah penting untuk melakukan ujian ini sebelum mengeluarkan apl. Panduan ini akan merangkumi ujian unit dengan Mocha dan Chai.

Kenapa Mocha dan Chai?

Mocha ialah rangka kerja ujian JavaScript yang kaya dengan ciri yang berjalan pada Node.js, menjadikan ujian tak segerak mudah dan menyeronokkan. Ia menyediakan fungsi yang dilaksanakan dalam susunan tertentu, mengumpul keputusan ujian dan menawarkan pelaporan yang tepat.

Chai ialah perpustakaan penegasan BDD/TDD yang boleh digunakan dengan mana-mana rangka kerja ujian JavaScript. Ia menawarkan beberapa antara muka, membolehkan pembangun memilih gaya penegasan yang mereka rasa paling selesa.

Kebaikan menggunakan Mocha dan Chai

1. Ketegasan yang boleh dibaca dan ekspresif
   
   Chai menyediakan gaya penegasan dan pilihan sintaks berbeza yang berfungsi dengan baik dengan Mocha, membolehkan anda memilih gaya yang sesuai dengan keperluan anda untuk kejelasan dan kebolehbacaan.

2. Sokongan untuk ujian tak segerak
   
   Mocha mengendalikan ujian tak segerak dengan mudah, membolehkan anda menguji kod tak segerak dalam aplikasi Node.js tanpa memerlukan perpustakaan tambahan atau persediaan yang kompleks.

Menyediakan Persekitaran Pengujian

Memasang kebergantungan

Pertama, mari kita sediakan projek Node.js baharu dan pasang kebergantungan yang diperlukan:

mkdir auth-api-testing
cd auth-api-testing
npm init -y

# Install production dependencies
npm install express jsonwebtoken mongoose bcryptjs dotenv

# Install development dependencies
npm install --save-dev mocha chai chai-http supertest nyc

Sediakan skrip ujian

Tambahkan skrip berikut pada package.json anda:

{
  "scripts": {
    "test": "NODE_ENV=test mocha --timeout 10000 --exit",
    "test:coverage": "nyc npm test"
  }
}

Gambaran Keseluruhan Projek

Sebelum terjun ke dalam ujian, mari kita fahami aplikasi yang akan kita uji. Kami sedang membina API pengesahan yang mudah tetapi selamat dengan ciri berikut.

Struktur Aplikasi

src/
├── models/
│   └── user.model.js       # User schema and model
├── routes/
│   ├── auth.routes.js      # Authentication routes
│   └── user.routes.js      # User management routes
├── middleware/
│   ├── auth.middleware.js  # JWT verification middleware
│   └── validate.js         # Request validation middleware
├── controllers/
│   ├── auth.controller.js  # Authentication logic
│   └── user.controller.js  # User management logic
└── app.js                  # Express application setup

Titik Akhir API

1. Titik Tamat Pengesahan:

POST /api/auth/register
- Registers new user
- Accepts: { email, password, name }
- Returns: { token, user }

POST /api/auth/login
- Authenticates existing user
- Accepts: { email, password }
- Returns: { token, user }

1. Titik Akhir Pengguna:

GET /api/users/profile
- Gets current user profile
- Requires: JWT Authentication
- Returns: User object

PUT /api/users/profile
- Updates user profile
- Requires: JWT Authentication
- Accepts: { name, email }
- Returns: Updated user object

Persediaan persekitaran untuk ujian

Buat fail .env.test untuk konfigurasi khusus ujian:

PORT=3001
MONGODB_URI=mongodb://localhost:27017/auth-api-test
JWT_SECRET=your-test-secret-key

Memahami Struktur Ujian

Mari buat ujian fail pertama kami test/auth.test.js

const chai = require('chai');
const chaiHttp = require('chai-http');
const app = require('../src/app');
const User = require('../src/models/user.model');

chai.use(chaiHttp);
const expect = chai.expect;

describe('Auth API Tests', () => {
  // Runs before all tests
  before(async () => {
    await User.deleteMany({});
  });

  // Runs after each test
  afterEach(async () => {
    await User.deleteMany({});
  });

  // Test suites will go here
});

Uji Cangkuk Kitar Hayat

Mocha menyediakan beberapa cangkuk untuk persediaan ujian dan pembersihan:

• before(): Berjalan sekali sebelum semua ujian

• after(): Berjalan sekali selepas semua ujian

• beforeEach(): Berjalan sebelum setiap ujian

• afterEach(): Berjalan selepas setiap ujian

Mocha's describe() and it() Blocks

Ujian diatur menggunakan blok describe() untuk mengumpulkan ujian yang berkaitan dan blok it() untuk kes ujian individu:

mkdir auth-api-testing
cd auth-api-testing
npm init -y

# Install production dependencies
npm install express jsonwebtoken mongoose bcryptjs dotenv

# Install development dependencies
npm install --save-dev mocha chai chai-http supertest nyc

Menulis suite ujian pertama kami

Menguji Pendaftaran dan Log Masuk

{
  "scripts": {
    "test": "NODE_ENV=test mocha --timeout 10000 --exit",
    "test:coverage": "nyc npm test"
  }
}

Pengujian Pengesahan

src/
├── models/
│   └── user.model.js       # User schema and model
├── routes/
│   ├── auth.routes.js      # Authentication routes
│   └── user.routes.js      # User management routes
├── middleware/
│   ├── auth.middleware.js  # JWT verification middleware
│   └── validate.js         # Request validation middleware
├── controllers/
│   ├── auth.controller.js  # Authentication logic
│   └── user.controller.js  # User management logic
└── app.js                  # Express application setup

Pengujian Pangkalan Data

Menyediakan Pangkalan Data Ujian

POST /api/auth/register
- Registers new user
- Accepts: { email, password, name }
- Returns: { token, user }

POST /api/auth/login
- Authenticates existing user
- Accepts: { email, password }
- Returns: { token, user }

Menguji Operasi CRUD

GET /api/users/profile
- Gets current user profile
- Requires: JWT Authentication
- Returns: User object

PUT /api/users/profile
- Updates user profile
- Requires: JWT Authentication
- Accepts: { name, email }
- Returns: Updated user object

Amalan Terbaik

Simpan Test Atomic

• Setiap ujian harus berdiri sendiri dan tidak bergantung pada ujian lain

• Ujian seharusnya boleh dijalankan dalam sebarang urutan

• Gunakan cangkuk sebelum, selepas, sebelumSetiap dan selepasSetiap untuk persediaan dan pembersihan yang betul
  

  PORT=3001
  MONGODB_URI=mongodb://localhost:27017/auth-api-test
  JWT_SECRET=your-test-secret-key
  

  Ikut Corak AAA

  • Susun: Sediakan data dan syarat ujian
  • Tindakan: Jalankan kod yang sedang diuji
  • Tegaskan: Sahkan keputusan

  const chai = require('chai');
  const chaiHttp = require('chai-http');
  const app = require('../src/app');
  const User = require('../src/models/user.model');
  
  chai.use(chaiHttp);
  const expect = chai.expect;
  
  describe('Auth API Tests', () => {
    // Runs before all tests
    before(async () => {
      await User.deleteMany({});
    });
  
    // Runs after each test
    afterEach(async () => {
      await User.deleteMany({});
    });
  
    // Test suites will go here
  });
  

  Kes Tepi Ujian

  Uji keadaan sempadan, senario ralat, input tidak sah dan nilai kosong atau batal.
  

  describe('Auth API Tests', () => {
    describe('POST /api/auth/register', () => {
      it('should register a new user successfully', async () => {
        // Test implementation
      });
  
      it('should return error when email already exists', async () => {
        // Test implementation
      });
    });
  });
  

  Gunakan Nama Ujian Deskriptif

  Nama ujian hendaklah menerangkan dengan jelas senario yang diuji, mengikut konvensyen penamaan yang konsisten dan menyertakan gelagat yang dijangkakan.
  

  describe('POST /api/auth/register', () => {
    it('should register a new user successfully', async () => {
      const res = await chai
        .request(app)
        .post('/api/auth/register')
        .send({
          email: 'test@example.com',
          password: 'Password123!',
          name: 'Test User'
        });
  
      expect(res).to.have.status(201);
      expect(res.body).to.have.property('token');
      expect(res.body).to.have.property('user');
      expect(res.body.user).to.have.property('email', 'test@example.com');
    });
  
    it('should return 400 when email already exists', async () => {
      // First create a user
      await chai
        .request(app)
        .post('/api/auth/register')
        .send({
          email: 'test@example.com',
          password: 'Password123!',
          name: 'Test User'
        });
  
      // Try to create another user with same email
      const res = await chai
        .request(app)
        .post('/api/auth/register')
        .send({
          email: 'test@example.com',
          password: 'Password123!',
          name: 'Test User 2'
        });
  
      expect(res).to.have.status(400);
      expect(res.body).to.have.property('error');
    });
  });
  

  Olok-olok Ketergantungan Luaran

  • Gunakan stub dan olok-olok untuk perkhidmatan luar
  • Asingkan kod yang sedang diuji
  • Kawal persekitaran ujian

  describe('Protected Routes', () => {
    let token;
    let userId;
  
    beforeEach(async () => {
      // Create a test user and get token
      const res = await chai
        .request(app)
        .post('/api/auth/register')
        .send({
          email: 'test@example.com',
          password: 'Password123!',
          name: 'Test User'
        });
  
      token = res.body.token;
      userId = res.body.user._id;
    });
  
    it('should get user profile with valid token', async () => {
      const res = await chai
        .request(app)
        .get('/api/users/profile')
        .set('Authorization', `Bearer ${token}`);
  
      expect(res).to.have.status(200);
      expect(res.body).to.have.property('email', 'test@example.com');
    });
  
    it('should return 401 with invalid token', async () => {
      const res = await chai
        .request(app)
        .get('/api/users/profile')
        .set('Authorization', 'Bearer invalid-token');
  
      expect(res).to.have.status(401);
    });
  });
  

  Tangani Janji Dengan Betul

  • Sentiasa pulangkan janji atau gunakan async/tunggu
  • Gunakan pengendalian ralat yang betul
  • Uji kedua-dua kes kejayaan dan kegagalan

  const mongoose = require('mongoose');
  
  before(async () => {
    await mongoose.connect(process.env.MONGODB_URI_TEST);
  });
  
  after(async () => {
    await mongoose.connection.dropDatabase();
    await mongoose.connection.close();
  });
  

  Tetapkan Tamat Masa yang Sesuai

  • Tetapkan tamat masa yang realistik untuk operasi tak segerak
  • Konfigurasikan tamat masa global dalam konfigurasi mocha
  • Timpa tamat masa untuk ujian tertentu apabila diperlukan

  describe('User CRUD Operations', () => {
    it('should update user profile', async () => {
      const res = await chai
        .request(app)
        .put(`/api/users/${userId}`)
        .set('Authorization', `Bearer ${token}`)
        .send({
          name: 'Updated Name'
        });
  
      expect(res).to.have.status(200);
      expect(res.body).to.have.property('name', 'Updated Name');
    });
  
    it('should delete user account', async () => {
      const res = await chai
        .request(app)
        .delete(`/api/users/${userId}`)
        .set('Authorization', `Bearer ${token}`);
  
      expect(res).to.have.status(200);
  
      // Verify user is deleted
      const user = await User.findById(userId);
      expect(user).to.be.null;
    });
  });
  

Memperkenalkan Penjana Ujian Unit Keploy

Menulis kes ujian manual untuk mocha dengan chai, walaupun berkesan, selalunya mempunyai beberapa cabaran:

1. Memakan masa: Membuat set ujian terperinci dengan tangan boleh mengambil banyak masa, terutamanya untuk pangkalan kod yang besar.

2. Sukar untuk diselenggara: Apabila aplikasi anda berubah, mengemas kini dan menyelenggara ujian manual menjadi lebih kompleks dan terdedah kepada ralat.

3. Liputan tidak konsisten: Pembangun mungkin menumpukan pada laluan utama, kes kelebihan yang hilang atau senario ralat yang boleh menyebabkan pepijat dalam pengeluaran.

4. Bergantung kepada kemahiran: Kualiti dan keberkesanan ujian manual sangat bergantung pada kemahiran ujian dan kebiasaan pembangun dengan pangkalan kod.

5. Berulang-ulang dan membosankan: Menulis struktur ujian yang serupa untuk berbilang komponen atau fungsi boleh membosankan, mungkin menyebabkan kurang perhatian terhadap perincian.

6. Maklum balas tertunda: Masa yang diperlukan untuk menulis ujian manual boleh melambatkan pembangunan, menangguhkan maklum balas penting tentang kualiti dan fungsi kod.

Untuk menangani isu ini, Keploy telah memperkenalkan ut-gen yang menggunakan AI untuk mengautomasikan dan menambah baik proses ujian, yang merupakan pelaksanaan pertama kertas penyelidikan Meta LLM yang memahami semantik kod dan mencipta ujian unit yang bermakna.

Ia bertujuan untuk mengautomasikan penjanaan ujian unit (UTG) dengan cepat menghasilkan ujian unit yang menyeluruh. Ini mengurangkan keperluan untuk kerja manual yang berulang, menambah baik kes tepi dengan mengembangkan ujian untuk merangkumi senario yang lebih kompleks yang sering terlepas secara manual dan meningkatkan liputan ujian untuk memastikan liputan lengkap apabila pangkalan kod berkembang.

%[https://marketplace.visualstudio.com/items?itemName=Keploy.keployio]

Ciri Utama

• Automasikan penjanaan ujian unit (UTG): Cepat hasilkan ujian unit komprehensif dan kurangkan usaha manual yang berlebihan.

• Tingkatkan kes tepi: Lanjutkan dan tingkatkan skop ujian untuk merangkumi senario yang lebih kompleks yang sering terlepas secara manual.

• Tingkatkan liputan ujian: Apabila pangkalan kod berkembang, memastikan liputan menyeluruh dapat dilaksanakan.

Kesimpulan

Kesimpulannya, menguasai ujian backend Node.js dengan Mocha dan Chai adalah penting untuk pembangun yang mahukan aplikasi mereka boleh dipercayai dan kukuh. Dengan menggunakan rangka kerja ujian Mocha dan pustaka penegasan Chai yang jelas, pembangun boleh mencipta suite ujian terperinci yang merangkumi banyak bahagian kod mereka, daripada ujian unit mudah kepada operasi async yang kompleks. Mengikuti amalan terbaik seperti mengekalkan fokus ujian, menggunakan nama yang jelas dan mengendalikan janji dengan betul boleh meningkatkan proses ujian anda. Dengan menggunakan alatan dan teknik ini dalam aliran kerja pembangunan anda, anda boleh menemui pepijat lebih awal, meningkatkan kualiti kod dan menyampaikan aplikasi yang lebih selamat dan cekap.

Soalan Lazim

Apakah perbezaan antara Mocha dan Chai, dan adakah saya memerlukan kedua-duanya?

Walaupun kedua-duanya adalah alat ujian, ia mempunyai tujuan yang berbeza. Mocha ialah rangka kerja ujian yang menyediakan struktur untuk mengatur dan menjalankan ujian (menggunakan blok describe() dan it(). Chai ialah perpustakaan penegasan yang menyediakan fungsi untuk mengesahkan hasil (seperti jangkakan(), harus dan tegaskan). Walaupun anda boleh menggunakan Mocha tanpa Chai, menggunakannya bersama-sama memberikan anda penyelesaian ujian yang lebih lengkap dan ekspresif.

Bagaimanakah cara saya menyediakan dan membersihkan data ujian antara ujian?

Mocha menyediakan beberapa cangkuk kitaran hayat untuk mengurus data ujian:

• sebelum(): Jalankan sekali sebelum semua ujian

• beforeEach(): Berlari sebelum setiap ujian

• afterEach(): Jalankan selepas setiap ujian

• selepas(): Jalankan sekali selepas semua ujian

Contoh:

mkdir auth-api-testing
cd auth-api-testing
npm init -y

# Install production dependencies
npm install express jsonwebtoken mongoose bcryptjs dotenv

# Install development dependencies
npm install --save-dev mocha chai chai-http supertest nyc

Bagaimanakah saya harus menstrukturkan ujian saya untuk organisasi dan penyelenggaraan yang lebih baik?

1. Ujian berkaitan kumpulan menggunakan blok describe()

2. Gunakan nama ujian deskriptif yang menyatakan dengan jelas tingkah laku yang diharapkan

3. Ikuti corak AAA (Arrange-Act-Assert) dalam setiap ujian

4. Pastikan ujian atom dan bebas

5. Atur fail ujian untuk mencerminkan struktur kod sumber anda

Contoh:

{
  "scripts": {
    "test": "NODE_ENV=test mocha --timeout 10000 --exit",
    "test:coverage": "nyc npm test"
  }
}

Apakah perbezaan antara sebelum, sebelumSetiap, selepas, dan selepasSetiap?

'before' dijalankan sekali sebelum semua ujian, 'beforeEach' dijalankan sebelum setiap ujian individu, 'afterEach' dijalankan selepas setiap ujian individu dan 'after' dijalankan sekali selepas semua ujian selesai. Ini berguna untuk menyediakan dan membersihkan data ujian.

Bagaimanakah saya hendak menguji kod async?

Anda boleh menggunakan async/menunggu atau mengembalikan janji dalam ujian anda. Cuma tambah 'async' sebelum fungsi ujian anda dan gunakan 'menunggu' apabila memanggil operasi async. Pastikan anda menetapkan tamat masa yang sesuai untuk operasi yang lebih lama.

Atas ialah kandungan terperinci Ujian unit untuk NodeJS menggunakan Mocha dan Chai. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!