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:

• Integrasi top-down: Memulai dari modul tingkat tertinggi dan mengintegrasikan ke bawah.
• Integrasi bottom-up: Memulai dari modul tingkat terendah dan mengintegrasikan ke atas.
• Integrasi big-bang: Mengintegrasikan semua modul secara bersamaan. Pendekatan ini umumnya kurang direkomendasikan karena sulitnya mengisolasi masalah.
• Integrasi sandwich: Kombinasi dari integrasi top-down dan bottom-up.

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:

• Memastikan Keandalan Sistem: Membantu mengidentifikasi masalah integrasi di awal siklus pengembangan, mencegah kegagalan tak terduga di lingkungan produksi.
• Memvalidasi Integritas Data: Memverifikasi bahwa data ditransmisikan dan diubah dengan benar di antara berbagai API.
• Meningkatkan Kinerja Aplikasi: Dapat mengungkap hambatan kinerja (bottleneck) yang terkait dengan interaksi API.
• Meningkatkan Keamanan: Dapat mengidentifikasi kerentanan keamanan yang timbul dari integrasi API yang tidak tepat. Misalnya, memastikan autentikasi dan otorisasi yang benar saat API berkomunikasi.
• Mengurangi Biaya Pengembangan: Memperbaiki masalah integrasi di awal jauh lebih murah daripada menanganinya di tahap akhir siklus pengembangan.

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:

• Mudah Digunakan: Supertest menawarkan API yang sederhana dan intuitif untuk mengirim permintaan HTTP dan membuat asersi.
• Pengujian Asinkron: Ia menangani operasi asinkron dengan lancar, membuatnya ideal untuk menguji API yang mengandalkan logika asinkron.
• Antarmuka Fasih (Fluent Interface): Ia menyediakan antarmuka fasih, memungkinkan Anda untuk merangkai metode bersama-sama untuk pengujian yang ringkas dan mudah dibaca.
• Dukungan Asersi Komprehensif: Ia mendukung berbagai macam asersi untuk memverifikasi kode status, header, dan body respons.
• Integrasi dengan Kerangka Kerja Pengujian: Ia terintegrasi dengan mulus dengan kerangka kerja pengujian populer seperti Jest dan Mocha, memungkinkan Anda untuk menggunakan infrastruktur pengujian yang sudah ada.

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
            

              
                Copy
              
            
          

2. Instal dependensi:

            npm install --save-dev jest supertest
npm install express  # Atau kerangka kerja pilihan Anda untuk membuat API
            

              
                Copy
              
            
          

3. Konfigurasi Jest: Tambahkan yang berikut ke file package.json Anda:

            {
  "scripts": {
    "test": "jest"
  }
}
            

              
                Copy
              
            
          

4. 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

            

              
                Copy
              
            
          

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!');
  });
});

            

              
                Copy
              
            
          

Penjelasan:

• Kita mengimpor supertest dan aplikasi Express kita.
• Kita menggunakan describe untuk mengelompokkan tes kita.
• Kita menggunakan it untuk mendefinisikan kasus uji spesifik.
• Kita menggunakan request(app) untuk membuat agen Supertest yang akan membuat permintaan ke aplikasi kita.
• Kita menggunakan .get('/hello') untuk mengirim permintaan GET ke endpoint /hello.
• Kita menggunakan await untuk menunggu respons. Metode Supertest mengembalikan promise, memungkinkan kita menggunakan async/await untuk kode yang lebih bersih.
• Kita menggunakan expect(response.statusCode).toBe(200) untuk memastikan bahwa kode status respons adalah 200 OK.
• Kita menggunakan expect(response.text).toBe('Hello, World!') untuk memastikan bahwa body respons adalah "Hello, World!".

Untuk menjalankan tes, jalankan perintah berikut di terminal Anda:

            npm test
            

              
                Copy
              
            
          

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);
});
            

              
                Copy
              
            
          

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);
  });
});
            

              
                Copy
              
            
          

Penjelasan:

• Kita menggunakan .post('/users') untuk mengirim permintaan POST ke endpoint /users.
• Kita menggunakan .send(userData) untuk mengirim objek userData di body permintaan. Supertest secara otomatis mengatur header Content-Type menjadi application/json.
• Kita menggunakan .expect(201) untuk memastikan bahwa kode status respons adalah 201 Created.
• Kita menggunakan expect(response.body).toHaveProperty('id') untuk memastikan bahwa body respons berisi properti id.
• Kita menggunakan expect(response.body.name).toBe(userData.name) dan expect(response.body.email).toBe(userData.email) untuk memastikan bahwa properti name dan email di body respons cocok dengan data yang kita kirim dalam permintaan.

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');
  });
});
            

              
                Copy
              
            
          

Penjelasan:

• Kita menggunakan .set('Authorization', `Bearer ${token}`) untuk mengatur header Authorization menjadi Bearer ${token}.

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
            

              
                Copy
              
            
          

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!');
  });
});
            

              
                Copy
              
            
          

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
  });
});
            

              
                Copy
              
            
          

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:

• Uji Alur Kerja End-to-End: Fokus pada pengujian alur kerja pengguna yang lengkap daripada endpoint API yang terisolasi. Ini membantu mengidentifikasi masalah integrasi yang mungkin tidak terlihat saat menguji API individual secara terpisah.
• Gunakan Data Realistis: Gunakan data realistis dalam tes Anda untuk mensimulasikan skenario dunia nyata. Ini termasuk menggunakan format data yang valid, nilai batas, dan data yang berpotensi tidak valid untuk menguji penanganan kesalahan.
• Isolasi Tes Anda: Pastikan tes Anda independen satu sama lain dan tidak bergantung pada state bersama. Ini akan membuat tes Anda lebih andal dan lebih mudah untuk di-debug. Pertimbangkan untuk menggunakan database tes khusus atau melakukan mocking pada dependensi eksternal.
• Mock Dependensi Eksternal: Gunakan mocking untuk mengisolasi API Anda dari dependensi eksternal, seperti database, API pihak ketiga, atau layanan lainnya. Ini akan membuat tes Anda lebih cepat dan lebih andal, dan juga akan memungkinkan Anda untuk menguji skenario yang berbeda tanpa bergantung pada ketersediaan layanan eksternal. Pustaka seperti nock berguna untuk melakukan mocking pada permintaan HTTP.
• Tulis Tes Komprehensif: Upayakan cakupan tes yang komprehensif, termasuk tes positif (memverifikasi respons yang berhasil), tes negatif (memverifikasi penanganan kesalahan), dan tes batas (memverifikasi kasus-kasus ekstrem).
• Otomatiskan Tes Anda: Integrasikan tes integrasi API Anda ke dalam pipeline continuous integration (CI) Anda untuk memastikan tes tersebut dijalankan secara otomatis setiap kali ada perubahan pada basis kode. Ini akan membantu mengidentifikasi masalah integrasi sejak dini dan mencegahnya mencapai produksi.
• Dokumentasikan Tes Anda: Dokumentasikan tes integrasi API Anda dengan jelas dan ringkas. Ini akan memudahkan pengembang lain untuk memahami tujuan tes dan memeliharanya dari waktu ke waktu.
• Gunakan Variabel Lingkungan: Simpan informasi sensitif seperti kunci API, kata sandi database, dan nilai konfigurasi lainnya di variabel lingkungan daripada menuliskannya secara langsung (hardcoding) di dalam tes Anda. Ini akan membuat tes Anda lebih aman dan lebih mudah dikonfigurasi untuk lingkungan yang berbeda.
• Pertimbangkan Kontrak API: Manfaatkan pengujian kontrak API untuk memvalidasi bahwa API Anda mematuhi kontrak yang ditentukan (misalnya, OpenAPI/Swagger). Ini membantu memastikan kompatibilitas antara layanan yang berbeda dan mencegah perubahan yang merusak. Alat seperti Pact dapat digunakan untuk pengujian kontrak.

Kesalahan Umum yang Harus Dihindari

• Tidak mengisolasi tes: Tes harus independen. Hindari bergantung pada hasil tes lain.
• Menguji detail implementasi: Fokus pada perilaku dan kontrak API, bukan implementasi internalnya.
• Mengabaikan penanganan kesalahan: Uji secara menyeluruh bagaimana API Anda menangani input yang tidak valid, kasus-kasus ekstrem, dan kesalahan yang tidak terduga.
• Melewatkan pengujian autentikasi dan otorisasi: Pastikan mekanisme keamanan API Anda diuji dengan benar untuk mencegah akses yang tidak sah.

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.