Hosting API memikul tanggung jawab untuk memastikannya berfungsi. Tidak ada cara yang lebih baik atau lebih mudah untuk melakukannya selain pengujian otomatis dengan alat seperti Mocha.

Pengembangan perangkat lunak modern memanfaatkan API dengan baik. Mereka berfungsi sebagai penghubung penting antara aplikasi sisi klien dan aplikasi backend, serta antara aplikasi internal atau eksternal yang berbeda.

API memungkinkan komunikasi dan pertukaran data yang lancar, memungkinkan komponen perangkat lunak berinteraksi satu sama lain dengan lancar. Memastikan keandalan, fungsionalitas, dan kinerja API ini sangat penting untuk memberikan pengalaman pengguna yang mulus dan menjaga integritas sistem secara keseluruhan.

Oleh karena itu penting untuk menguji API Anda secara menyeluruh untuk menandai dan memperbaiki bug selama pengembangan untuk mencegah potensi kegagalan sistem di lingkungan produksi.

Menguji API Node.js Menggunakan Mocha, Chai, dan Chai-HTTP

Moka adalah kerangka pengujian yang banyak digunakan yang kompatibel dengan berbagai

instagram viewer
kerangka JavaScript. Salah satu fitur utamanya adalah test runner fleksibel yang menyederhanakan proses pengelolaan dan pelaksanaan kasus uji secara efektif.

Ini juga mendukung berbagai gaya pengujian, termasuk pengujian sinkron dan asinkron, memungkinkan berbagai skenario pengujian.

Di samping itu, Chai Dan Chai-HTTP adalah pustaka pernyataan yang dapat Anda gunakan bersama dengan Mocha. Chai menyediakan berbagai antarmuka pernyataan yang ekspresif dan dapat dibaca seperti seharusnya, mengharapkan, dan menegaskan. Sementara, Chai-HTTP, perpanjangan dari Chai, menyediakan antarmuka yang dirancang khusus untuk menguji permintaan HTTP dan menyatakan tanggapannya.

Dengan menggunakan Mocha bersamaan dengan Chai dan Chai-HTTP, Anda dapat menguji API secara efektif. Alur kerja pengujian meliputi:

  • Membuat permintaan HTTP ke titik akhir API yang ditentukan.
  • Mendefinisikan respon yang diharapkan.
  • Memvalidasi data yang diterima dari sumber yang ditentukan, kode status HTTP, dan lainnya.

Anda juga dapat mensimulasikan skenario pengujian kesalahan API yang mungkin muncul dalam situasi tersebut dan tindakan apa yang harus dipicu jika hal itu terjadi.

Anda dapat menemukan kode proyek ini di dalamnya repositori GitHub.

Menyiapkan Proyek Express.js dan Database MongoDB

Untuk memulai, membuat server web Ekspres, dan instal paket-paket ini:

npm instal cors dotenv mongoose mongodb

Berikutnya, membuat database MongoDB atau konfigurasikan cluster MongoDB di cloud. Kemudian salin URL koneksi database, buat a .env file di direktori root, dan rekatkan di string koneksi database:

CONNECTION_STRING="string koneksi"

Untuk menyelesaikan proses penyiapan, Anda perlu mengonfigurasi koneksi database dan menentukan model data untuk data pengguna Anda. Lihat kode di repositori GitHub proyek ini untuk:

  • Konfigurasi koneksi database, di utils/db.js.
  • Tentukan skema data pengguna di model/pengguna.model.js.

Tentukan Fungsi Handler untuk Rute API

Fungsi pengontrol akan mengatur penambahan dan pengambilan data pengguna di database. Untuk memastikan fungsionalitas fungsi penangan ini, Anda akan menguji apakah mereka berhasil memposting dan mengambil data dari database.

Di direktori root, buat a controllers/userControllers.js file dan tambahkan kode berikut:

const Pengguna = memerlukan('../model/pengguna.model');
ekspor.registerUser = asinkron (req, res) => {
const { nama pengguna, kata sandi } = req.body;


mencoba {
menunggu Pengguna.buat({ nama pengguna, kata sandi});
 res.status(201).mengirim({ pesan: 'Pengguna berhasil terdaftar' });
 } menangkap (kesalahan) {
menghibur.log (kesalahan);
 res.status(500).mengirim({ pesan: 'Terjadi kesalahan!! ' });
 }
};
ekspor.getUsers = asinkron (req, res) => {
mencoba {
const pengguna = menunggu Pengguna.temukan({});
 res.json (pengguna);
 } menangkap (kesalahan) {
menghibur.log (kesalahan);
 res.status(500).mengirim({ pesan: 'Terjadi kesalahan!!' });
 }
};

Tentukan Rute API

Buat yang baru rute/userRoutes.js file di direktori root dan tambahkan kode berikut.

const mengungkapkan = memerlukan('cepat');
const router = ekspres. Perute();
const userController = memerlukan('../controllers/userControllers');
router.post('/api/daftar', userControllers.registerUser);
router.dapatkan('/api/pengguna', userControllers.getUsers);
modul.ekspor = perute;

Tentukan Titik Masuk Server Anda

Perbarui Anda server.js file dengan kode berikut.

const mengungkapkan = memerlukan('cepat');
const kor = memerlukan('kor');
const aplikasi = ekspres();
const pelabuhan = 5000;
memerlukan('dotenv'.config();
const connectDB = memerlukan('./utils/db');
connectDB();


app.use (express.json());
app.use (express.urlencoded({ diperpanjang: BENAR }));
app.use (cors());


const rute pengguna = memerlukan('./routes/userRoutes');
aplikasi.penggunaan('/', rute pengguna);


app.listen (port, () => {
menghibur.catatan(`Server mendengarkan di http://localhost:${port}`);
});
modul.ekspor = aplikasi;

Tulis dan Jalankan Test Case Dengan Mocha

Dengan API pengguna di tempat, lanjutkan dan konfigurasikan lingkungan pengujian. Pertama, instal paket-paket ini sebagai dependensi dev.

npm instal mocha chai chai-http --save-dev

Sekarang, tambahkan skrip berikut ke file package.json Anda.

"skrip": {
"tes": "moka --waktu habis 10.000"
},

Perintah ini akan mengeksekusi test case—menambahkan properti timeout dengan nilai yang sesuai memungkinkan Anda untuk mengontrol waktu maksimum yang diperbolehkan untuk mengeksekusi test case individual.

Ini dapat berguna untuk mencegah pengujian berjalan tanpa batas waktu atau menyelesaikan terlalu cepat sebelum kasus pengujian selesai.

Uji Titik Akhir API

Di direktori root, buat folder baru dan beri nama tes. Di dalam folder ini, buat yang baru pengguna.tes.js file dan tambahkan kode berikut untuk kasus uji titik akhir POST.

const cha = memerlukan('chai');
const chaiHttp = memerlukan('chai-http');
const aplikasi = memerlukan('../server'); 
chai.use (chaiHttp);
const mengharapkan = chai.berharap;


menggambarkan('API Pengguna', () => {
 menggambarkan('POST /api/daftar', () => {
 dia('harus menangani pendaftaran pengguna', (selesai) => {
 chai.permintaan (aplikasi)
 .pos('/api/daftar')
 .mengirim({ nama belakang: 'pengguna uji', kata sandi: 'tes kata sandi' })
 .akhir((salah, res) => {
jika (salah) {
 mengharapkan (res).untuk.memiliki.status(500);
 mengharapkan (res.body).to.have.property('pesan').itu.adalah.sama('Terjadi kesalahan!!');
 } kalau tidak {
 mengharapkan (res).untuk.memiliki.status(201);
 mengharapkan (res.body).to.have.property('pesan').setara('Pengguna berhasil terdaftar');
 }
 Selesai();
 });
 });
 });
});

Kode ini menentukan kasus uji menggunakan HTTP Chai dan Chai untuk menguji fungsionalitas pendaftaran pengguna dari API pengguna.

Ini mengirimkan permintaan POST ke titik akhir yang ditentukan dan membuat pernyataan tentang respons API yang diharapkan, memverifikasi apakah fungsi pendaftaran pengguna berhasil atau jika terjadi kesalahan.

Berikut rincian komponen utama dari test case:

  • mengharapkan -Objek ini memungkinkan Anda menggunakan metode pernyataan Chai untuk membuat pernyataan tentang respons yang diharapkan dari API.
  • menggambarkan - Ini menjelaskan kasus uji terkait bersama-sama, dalam hal ini, tes terkait dengan API Pengguna. Blok deskripsikan yang bersarang lebih jauh mengelompokkan kasus uji terkait bersama-sama, dalam hal ini, the POST /api/daftar. Ini membantu mengatur kasus uji yang secara khusus terkait dengan fungsi tertentu.
  • dia - Fungsi ini menjelaskan perilaku yang diharapkan dari titik akhir API.
  • akhir - Fungsi ini mengirimkan permintaan dan menyediakan fungsi panggilan balik untuk menangani respons. Fungsi panggilan balik melakukan pernyataan menggunakan mengharapkan berfungsi untuk mengecek respon yang diterima dari API.
  • Selesai - Fungsi ini berjalan untuk menandai akhir dari test case.

Terakhir, tambahkan kode untuk kasus uji titik akhir GET tepat setelah kasus uji titik akhir POST.

menggambarkan('DAPATKAN /api/pengguna', () => {
 dia('harus mengambil semua data pengguna', (selesai) => {
 chai.permintaan (aplikasi)
 .mendapatkan('/api/pengguna')
 .akhir((salah, res) => {
jika (salah) {
 mengharapkan (res).untuk.memiliki.status(500);
 mengharapkan (res.body).to.have.property('pesan').itu.adalah.sama('Terjadi kesalahan saat mengambil data pengguna');
 } kalau tidak {
 mengharapkan (res).untuk.memiliki.status(200);
 harapkan (res.body).to.be.an('Himpunan');
 }
 Selesai();
 });
 });
});

Lanjutkan dan jalankan skrip pengujian di terminal Anda untuk menjalankan dua kasus pengujian.

uji npm

Jika eksekusi kasus pengujian tidak menemukan kesalahan apa pun, Anda akan melihat keluaran serupa yang menunjukkan bahwa pengujian berhasil.

Kegagalan pengujian dapat terjadi karena berbagai alasan, seperti masalah konektivitas jaringan selama permintaan HTTP ke database, data yang diperlukan hilang, kesalahan logis, dan masalah lainnya.

Mocha melakukan pekerjaan yang baik dalam mengidentifikasi dan menyoroti kesalahan tersebut, memberikan laporan pengujian yang jelas dan terperinci dalam log yang ditampilkan di jendela terminal. Ini memungkinkan Anda untuk dengan mudah mengidentifikasi dan mendiagnosis masalah spesifik yang menyebabkan kegagalan pengujian.

Mocha Tidak Memberi Anda Alasan untuk Tidak Menguji API Anda

Saat menguji fungsionalitas API Anda secara manual menggunakan alat seperti Tukang pos adalah pengujian yang valid pendekatan, memanfaatkan Mocha dan kerangka kerja pengujian lainnya untuk pengujian otomatis membawanya ke yang berikutnya tingkat.

Dengan alat pengujian ini, Anda dapat mengotomatiskan pengujian dengan cepat dan mudah untuk mencakup berbagai skenario dan kasus ekstrem. Hal ini memungkinkan Anda mendeteksi bug dengan cepat dan menyelesaikannya sebelum menerapkan API, memastikan Anda mengirimkan perangkat lunak berkualitas tinggi ke produksi.