M

MLOG

Bahasa Indonesia

Panduan komprehensif untuk pengujian integrasi yang berfokus pada pengujian API menggunakan Supertest, mencakup penyiapan, praktik terbaik, dan teknik canggih untuk pengujian aplikasi yang tangguh.

Pengujian Integrasi: Menguasai Pengujian API dengan Supertest

Dalam dunia pengembangan perangkat lunak, memastikan setiap komponen berfungsi dengan benar secara terpisah (pengujian unit) sangatlah penting. Namun, sama pentingnya untuk memverifikasi bahwa komponen-komponen ini bekerja sama dengan lancar. Di sinilah pengujian integrasi berperan. Pengujian integrasi berfokus pada validasi interaksi antara berbagai modul atau layanan dalam sebuah aplikasi. Artikel ini akan membahas secara mendalam tentang pengujian integrasi, khususnya berfokus pada pengujian API dengan Supertest, sebuah pustaka yang andal dan mudah digunakan untuk menguji asersi HTTP di Node.js.

Apa itu Pengujian Integrasi?

Pengujian integrasi adalah jenis pengujian perangkat lunak yang menggabungkan modul-modul perangkat lunak individual dan mengujinya sebagai satu kelompok. Tujuannya adalah untuk menemukan cacat dalam interaksi antar unit yang terintegrasi. Berbeda dengan pengujian unit, yang berfokus pada komponen individual, pengujian integrasi memverifikasi alur data dan alur kontrol antar modul. Pendekatan pengujian integrasi yang umum meliputi:

Dalam konteks API, pengujian integrasi melibatkan verifikasi bahwa berbagai API bekerja sama dengan benar, bahwa data yang dikirimkan di antara mereka konsisten, dan bahwa sistem secara keseluruhan berfungsi seperti yang diharapkan. Sebagai contoh, bayangkan sebuah aplikasi e-commerce dengan API terpisah untuk manajemen produk, autentikasi pengguna, dan pemrosesan pembayaran. Pengujian integrasi akan memastikan bahwa API-API ini berkomunikasi dengan benar, memungkinkan pengguna untuk menelusuri produk, masuk dengan aman, dan menyelesaikan pembelian.

Mengapa Pengujian Integrasi API Penting?

Pengujian integrasi API sangat penting karena beberapa alasan:

Bayangkan sebuah platform pemesanan perjalanan global. Pengujian integrasi API sangat penting untuk memastikan komunikasi yang lancar antara API yang menangani reservasi penerbangan, pemesanan hotel, dan gerbang pembayaran dari berbagai negara. Kegagalan dalam mengintegrasikan API-API ini dengan benar dapat menyebabkan pemesanan yang salah, kegagalan pembayaran, dan pengalaman pengguna yang buruk, yang berdampak negatif pada reputasi dan pendapatan platform.

Memperkenalkan Supertest: Alat Andal untuk Pengujian API

Supertest adalah abstraksi tingkat tinggi untuk menguji permintaan HTTP. Ia menyediakan API yang nyaman dan fasih untuk mengirim permintaan ke aplikasi Anda dan melakukan asersi pada responsnya. Dibangun di atas Node.js, Supertest dirancang khusus untuk menguji server HTTP Node.js. Ia bekerja dengan sangat baik dengan kerangka kerja pengujian populer seperti Jest dan Mocha.

Fitur Utama Supertest:

Menyiapkan Lingkungan Pengujian Anda

Sebelum kita mulai, mari kita siapkan lingkungan pengujian dasar. Kami akan mengasumsikan Anda telah menginstal Node.js dan npm (atau yarn). Kami akan menggunakan Jest sebagai kerangka kerja pengujian dan Supertest untuk pengujian API.

  1. Buat proyek Node.js:
mkdir api-testing-example
cd api-testing-example
npm init -y
  1. Instal dependensi:
npm install --save-dev jest supertest
npm install express  # Atau kerangka kerja pilihan Anda untuk membuat API
  1. Konfigurasi Jest: Tambahkan yang berikut ke file package.json Anda:
{
  "scripts": {
    "test": "jest"
  }
}
  1. Buat endpoint API sederhana: Buat file bernama app.js (atau serupa) dengan kode berikut:
const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Ekspor untuk pengujian

Menulis Tes Supertest Pertama Anda

Sekarang setelah lingkungan kita siap, mari kita tulis tes Supertest sederhana untuk memverifikasi endpoint API kita. Buat file bernama app.test.js (atau serupa) di root proyek Anda:

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

describe('GET /hello', () => {
  it('merespons dengan 200 OK dan mengembalikan "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

Penjelasan:

Untuk menjalankan tes, jalankan perintah berikut di terminal Anda:

npm test

Jika semuanya diatur dengan benar, Anda akan melihat tes berhasil.

Teknik Supertest Tingkat Lanjut

Supertest menawarkan berbagai fitur untuk pengujian API tingkat lanjut. Mari kita jelajahi beberapa di antaranya.

1. Mengirim Body Permintaan

Untuk mengirim data dalam body permintaan, Anda dapat menggunakan metode .send(). Sebagai contoh, mari kita buat endpoint yang menerima data JSON:

app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Mensimulasikan pembuatan pengguna di database
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});

Berikut cara Anda dapat menguji endpoint ini menggunakan Supertest:

describe('POST /users', () => {
  it('membuat pengguna baru', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});

Penjelasan:

2. Mengatur Header

Untuk mengatur header kustom dalam permintaan Anda, Anda dapat menggunakan metode .set(). Ini berguna untuk mengatur token autentikasi, tipe konten, atau header kustom lainnya.

describe('GET /protected', () => {
  it('memerlukan autentikasi', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('mengembalikan 200 OK dengan token yang valid', async () => {
    // Mensimulasikan mendapatkan token yang valid
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});

Penjelasan:

3. Menangani Cookie

Supertest juga dapat menangani cookie. Anda dapat mengatur cookie menggunakan metode .set('Cookie', ...), atau Anda dapat menggunakan properti .cookies untuk mengakses dan memodifikasi cookie.

4. Menguji Unggahan File

Supertest dapat digunakan untuk menguji endpoint API yang menangani unggahan file. Anda dapat menggunakan metode .attach() untuk melampirkan file ke permintaan.

5. Menggunakan Pustaka Asersi (Chai)

Meskipun pustaka asersi bawaan Jest sudah cukup untuk banyak kasus, Anda juga dapat menggunakan pustaka asersi yang lebih kuat seperti Chai dengan Supertest. Chai menyediakan sintaks asersi yang lebih ekspresif dan fleksibel. Untuk menggunakan Chai, Anda perlu menginstalnya:

npm install --save-dev chai

Kemudian, Anda dapat mengimpor Chai ke file tes Anda dan menggunakan asersinya:

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

describe('GET /hello', () => {
  it('merespons dengan 200 OK dan mengembalikan "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});

Catatan: Anda mungkin perlu mengonfigurasi Jest agar bekerja dengan benar dengan Chai. Ini sering kali melibatkan penambahan file setup yang mengimpor Chai dan mengonfigurasinya untuk bekerja dengan expect global Jest.

6. Menggunakan Kembali Agen

Untuk tes yang memerlukan penyiapan lingkungan tertentu (misalnya, autentikasi), sering kali bermanfaat untuk menggunakan kembali agen Supertest. Ini menghindari kode penyiapan yang berlebihan di setiap kasus uji.

describe('Tes API Terautentikasi', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Buat agen persisten
    // Mensimulasikan autentikasi
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('dapat mengakses sumber daya yang dilindungi', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('dapat melakukan tindakan lain yang memerlukan autentikasi', async () => {
    // Lakukan tindakan terautentikasi lainnya di sini
  });
});

Dalam contoh ini, kita membuat agen Supertest di hook beforeAll dan mengautentikasi agen tersebut. Tes-tes berikutnya di dalam blok describe kemudian dapat menggunakan kembali agen yang terautentikasi ini tanpa harus melakukan autentikasi ulang untuk setiap tes.

Praktik Terbaik untuk Pengujian Integrasi API dengan Supertest

Untuk memastikan pengujian integrasi API yang efektif, pertimbangkan praktik terbaik berikut:

Kesalahan Umum yang Harus Dihindari

Kesimpulan

Pengujian integrasi API adalah bagian penting dari proses pengembangan perangkat lunak. Dengan menggunakan Supertest, Anda dapat dengan mudah menulis tes integrasi API yang komprehensif dan andal yang membantu memastikan kualitas dan stabilitas aplikasi Anda. Ingatlah untuk fokus pada pengujian alur kerja end-to-end, menggunakan data realistis, mengisolasi tes Anda, dan mengotomatiskan proses pengujian Anda. Dengan mengikuti praktik terbaik ini, Anda dapat secara signifikan mengurangi risiko masalah integrasi dan memberikan produk yang lebih tangguh dan andal.

Seiring API terus mendorong aplikasi modern dan arsitektur microservices, pentingnya pengujian API yang tangguh, dan terutama pengujian integrasi, akan terus berkembang. Supertest menyediakan seperangkat alat yang andal dan mudah diakses bagi para pengembang di seluruh dunia untuk memastikan keandalan dan kualitas interaksi API mereka.