Mengonsumsi dan Menguji RESTful API menggunakan Postman

Postman
Postman merupakan tools yang sangat cocok untuk menguji sebuah API karena memiliki
fungsi yang relatif lengkap sebagai API caller dalam melakukan HTTP Request. Bahkan
untuk pengembangan API yang sudah kompleks, pengujian Postman dapat diintegrasikan
ke dalam alur CI/CD.

Postman merupakan tools yang sangat powerful dan mudah untuk digunakan. Ia memiliki
graphical user interface (GUI) sehingga dapat digunakan dan dipahami oleh kalangan
pemula sekalipun. Sebab, kita tak lagi berhadapan dengan kode yang rumit hanya
untuk membuat HTTP request seperti cURL.

Postman tersedia secara gratis dan dapat berjalan pada sistem operasi Windows,
Linux, maupun macOS.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------

Memasang Postman
Sebelum menguji notes API yang sudah kita buat menggunakan Postman, tentu kita
perlu memasang Postman pada komputer kita terlebih dahulu. Silakan ikuti instruksi
di bawah ini, sesuai dengan sistem operasi yang Anda gunakan yah.

Catatan:
Agar dapat mengikuti materi dengan baik, kami sarankan Anda untuk mengunduh Postman
versi 9 stabil. Tutorial dan link unduh di bawah ini kami sudah sesuaikan dengan
versi tersebut.

Untuk memasang Postman pada komputer Anda, silakan kunjungi halaman unduh Postman
dan tunggu hingga proses unduh selesai.

Setelah selesai, buka berkas instalasi Postman untuk memulai proses instalasi.

Tunggu hingga proses instalasi selesai. Kemudian aplikasi Postman akan terbuka
dengan sendirinya.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Mengonsumsi API menggunakan Postman

Untuk memulai menggunakan Postman, silakan buka aplikasi Postman yang telah Anda
pasang sebelumnya.

Sebelum menggunakannya, Anda ditawari untuk membuat akun Postman. Pendaftaran ini
bersifat opsional, Anda bisa mendaftar ataupun melewatinya dengan klik Skip and go
to the app.

Selamat datang di Postman! Untuk membuat HTTP Request baru, Anda bisa klik tombol
“+” (New Tab).

Kemudian Anda akan melihat halaman berikut

Di halaman inilah kita akan melakukan panggilan ke API. Sebelum itu, mari kita
breakdown beberapa komponen yang penting untuk Anda ketahui saat ini.
Komponen UI Postman
Di bagian atas aplikasi Postman, Anda bisa melihat komponen seperti gambar di atas.
Komponen ini merupakan tab dari halaman request. Seperti browser, ketika Anda
hendak membuka halaman browser baru, Anda bisa membuka tab baru. Begitu juga dengan
Postman, bila Anda ingin membuat request baru, Anda bisa membuka tab baru.

Lanjut di bagian bawahnya kita bisa melihat komponen berikut ini:

Di sini kita menentukan method dan path dari request yang akan dilakukan. Tombol
Send yang tampak, digunakan untuk mengirim permintaan pada path dan method yang
sudah ditentukan.

Postman mendukung seluruh method yang ada di HTTP. Secara mudah Anda bisa mengubah
method yang digunakan dengan menekan opsi dropdown yang tersedia.

Kita beralih ke komponen di bawahnya.

Komponen ini digunakan untuk menyisipkan data dalam bentuk params URL,
authorization, Headers, Body, dan lainnya. Anda dapat secara mudah menyisipkan data
pada request melalui komponen ini.

Kita lanjut ke komponen di bawahnya.

Ketika Anda mengirimkan request, response body akan tampak di sini. Response dari
server akan ditampilkan secara terformat sesuai dengan Content-Type yang diberikan
server. Jika responsnya HTML, ia akan di render layaknya pada browser. Jika JSON,
ia akan diformat dengan struktur JSON.

Sebenarnya masih banyak komponen lain yang tidak kita bahas. Postman memiliki
fungsionalitas yang cukup kompleks untuk sebuah API caller. Agar Anda tidak pusing
memikirkan kompleksnya Postman, kita tidak akan menggunakan fitur yang rumit dulu,
melainkan mari fokus saja ke fungsi utama sebagai API caller.

Setelah pengenalan singkat terhadap komponen UI yang ada di Postman. Sekarang

saatnya kita mencoba mengonsumsi API menggunakan Postman mulai dari menambahkan
catatan baru, mendapatkan seluruh catatan, mendapatkan catatan secara spesifik,
mengubah catatan, dan terakhir menghapus catatan.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Menambahkan Catatan Baru

Untuk menambahkan catatan baru, pada halaman request ubahlah method GET menjadi
POST. Kemudian isi request URL dengan localhost:5000/notes.

Jangan dulu tekan tombol Send ya. Kita perlu memberikan data catatan yang dikirim
melalui body request.

Pilih tab Body.

Lalu pilih opsi raw, kemudian ganti format text menjadi JSON, dan tuliskan struktur
JSON berikut:

{
"title": "Catatan A",
"tags": ["Android", "Web"],
"body": "Isi dari catatan A"
}
Sehingga halaman tampak seperti ini.

Sekarang silakan klik tombol Send. Anda akan melihat respons dari server.

Pastikan ketika melakukan permintaan server lokal Anda dalam keadaan berjalan yah.
Bila terhenti, silakan jalankan kembali dengan perintah npm run start-dev pada
Terminal proyek.

Secara default Postman akan memformat respons agar lebih mudah membacanya. Anda
bisa melihat respons asli yang belum terformat dengan memilih tab Raw.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Mendapatkan Seluruh Catatan yang Disimpan

Sekarang kita coba untuk mendapatkan seluruh catatan yang disimpan. Ayo kita buat
permintaan baru di tab berbeda. Silakan buka tab baru.

Isikan request URL dengan localhost:5000/notes menggunakan method GET untuk

mendapatkan seluruh catatan yang disimpan server.

Kita tidak perlu melampirkan data apa pun pada permintaan kali ini. Jadi Anda bisa
langsung klik tombol Send.

Tada! Anda bisa melihat responnya. Karena kita baru menambahkan satu buat catatan
saja, jadi baru ada satu yang muncul.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Mendapatkan Catatan Secara Spesifik

Lanjut kita coba konsumsi API untuk mendapatkan catatan secara spesifik. Seperti
biasa, buka halaman request dengan tab baru.

Pada request URL tuliskan localhost:5000/notes/<note id yang tersedia>. Anda bisa

lihat id yang tersedia ketika melakukan permintaan mendapatkan seluruh catatan.
Contohnya di sini, kita akan gunakan id ‘Y85P5Vxy9-ehb1pZ’ (tentu Anda tidak dapat
menggunakan id ini).

Untuk method yang digunakan, biarkan tetap GET.

Kita tidak perlu melampirkan data apa pun pada permintaan kali ini. Jadi yuk, kirim
permintaan dengan klik tombol Send. Anda akan mendapatkan respons catatan sesuai
dengan id yang Anda minta.

Anda juga bisa menguji untuk kasus yang menghasilkan respons gagal. Contohnya
dengan melakukan permintaan dengan id yang tidak valid.

Kirim permintaannya, lalu pastikan respons gagal yang didapat sesuai dengan
ekspektasi Anda.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Mengubah Catatan
Berikutnya kita coba untuk mengubah catatan yang sudah disimpan melalui Postman.
Seperti biasa, silakan buka halaman request baru.

Sekarang kita memiliki 4 tabs.

Isikan request URL dengan localhost:5000/notes/<note id yang tersedia> dan gunakan

HTTP method PUT. Untuk nilai note id, gunakan id yang sama pada request sebelumnya
(mendapatkan catatan secara spesifik), di mana pada contoh kali ini kita
menggunakan id ‘olf4TC3Z4B4mpXtH’.

Untuk mengubah catatan, kita perlu melampirkan data catatan terbaru pada body
request. Jadi yuk lampirkan struktur JSON berikut pada Body Request.

{
"title": "Catatan A Revisi",
"tags": ["Android", "Web"],
"body": "Isi dari catatan A revisi"
}

Dengan begitu request akan tampak seperti ini.

Permintaan siap dikirim. Silakan klik Send untuk mengirim dan lihat respons yang
didapat.

Catatan berhasil diubah! Untuk memastikan data catatan berubah, silakan lakukan
permintaan pada tab permintaan sebelumnya (mendapatkan catatan secara spesifik) dan
pastikan id catatan yang diminta sesuai.

Good! Perubahan berhasil diterapkan.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Menghapus Catatan
Terakhir, kita coba hapus catatan melalui Postman. Yuk kita buka kembali halaman
permintaan baru.

Isi request URL dengan localhost:5000/notes/<note id yang tersedia> dan gunakan

HTTP method DELETE. Seperti biasa, gunakan note id yang sama seperti permintaan
sebelumnya.

Untuk menghapus catatan, kita tidak memerlukan data apa pun yang dilampirkan di
body request. So it's all set! Silakan kirim permintaan dengan klik tombol Send.

Catatan berhasil dihapus! Kita pastikan catatan benar-benar terhapus dengan

melakukan permintaan ke catatan tersebut. Seharusnya permintaan akan gagal yah.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Automate Testing Using Postman

Di materi sebelumnya Anda sudah belajar bagaimana cara menguji API menggunakan
Postman secara manual. Ketahuilah bahwa dengan Postman Anda juga bisa melakukan uji
secara otomatis, sehingga tak perlu lagi melihat respons dari server secara manual
untuk memastikan responnya sesuai dengan harapan. Pengujian otomatis di Postman
menggunakan kode JavaScript, serupa dengan unit dan integration testing yang sudah
Anda pelajari di kelas Belajar Dasar Pemrograman JavaScript.
Melalui testing otomatis ini, kita bisa menguji nilai dari status code, properti
header, hingga body respons. Pengujian otomatis akan “pass” (berhasil) ketika semua
variabel yang diuji sesuai ekspektasi. Bila ada salah satu yang tidak sesuai, maka
pengujian akan “failed” (gagal).

Materi kali ini, kita akan mencoba menguji API secara otomatis. Namun sebelum itu,
sebaiknya Anda mengenal dulu fitur Collection dan Environment yang ada di Postman
karena keduanya akan digunakan dalam pengujian.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Postman Collection
Postman collection merupakan tempat menyimpan kumpulan request. Kita bisa
menganggap collection adalah sebuah folder yang menyimpan berkas, namun berkas itu
adalah request.

Setiap request yang Anda kirim di Postman sebenarnya akan tampak pada tab History
di sidebar.

Dalam penggunaan yang ringan, memilih dan menggunakan kembali request melalui
History merupakan pengalaman yang cukup nyaman. Namun bila Anda banyak melakukan
request, history request akan menumpuk tidak karuan. Dengan begitu, Anda akan
membutuhkan waktu yang lama untuk memilah dan memilih request yang ingin digunakan
kembali.

Dengan adanya collection, request bisa Anda kelompokkan sehingga lebih mudah untuk
diakses. Berikut adalah contoh collection Notes API Test.

Melalui collection, Anda bisa menjalankan seluruh request yang ada di dalamnya
sekaligus dengan urutan yang dapat Anda sesuaikan.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Postman Environment
Environment merupakan kumpulan dari variabel yang dapat digunakan pada request di
Postman. Ketika melakukan pengujian otomatis, terkadang kita perlu menyimpan nilai
pada sebuah variabel. Contohnya ketika melakukan request menambahkan catatan, kita
akan mendapatkan id catatan tersebut dari server. Id tersebut perlu disimpan pada
variabel agar dapat digunakan oleh request selanjutnya.

Variabel tak hanya digunakan untuk kasus tersebut saja, melainkan dapat juga untuk
menyimpan nilai token, auth-key, atau nilai lainnya yang dipakai selama proses uji.

Berikut adalah tampilan environment pada Postman.

Environment dapat digunakan pada collection atau spesifik request.

Untuk menggunakan variabel environment pada request, tuliskan nama variabel-nya

yang dibungkus dengan kurung kurawal ganda seperti ini:

{{noteId}}

Notasi tersebut dapat digunakan di request URL, parameters, headers, dan body data.
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Skenario Pengujian Otomatis

Kita akan melakukan pengujian dengan skenario yang sama seperti yang dilakukan
dengan cara manual. Berikut skenarionya:

Skenario 1: Adding Notes (Memasukkan catatan baru)

Pastikan response memiliki status code 201.
Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai yang sesuai.
Pastikan data pada response body memiliki noteId dan nilainya tidak kosong.

Skenario 2: Getting All Notes (Mendapatkan seluruh catatan)

Pastikan response memiliki status code 200.
Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai atau tipe data yang sesuai.
Pastikan data pada response body memiliki array notes dan terdapat minimal 1 item
di dalamnya.

Skenario 3: Getting Specified Note (Mendapatkan catatan secara spesifik)

Pastikan response memiliki status code 200.
Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response merupakan object.
Pastikan body response memiliki properti dan nilai atau tipe data yang sesuai.
Pastikan data pada response body memiliki properti note yang merupakan sebuah
objek.
Pastikan objek note di dalam data memiliki properti id, title, body, dan tags
dengan nilai yang sesuai.

Skenario 4: Update Note (Memperbarui data catatan)

Pastikan response memiliki status code 200.
Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai yang sesuai.
Ketika mengakses catatan yang diperbaharui
Pastikan catatan yang diperbarui memiliki nilai terbaru.

Skenario 5: Delete Note (Menghapus catatan)

Pastikan response memiliki status code 200.
Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai yang sesuai.
Ketika mengakses catatan yang dihapus
Pastikan catatan yang dihapus tidak ditemukan.
Yuk kita mulai buat pengujian otomatisnya.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Membuat Collection dan Environment

Sebelum membuat request dan mengujinya, kita siapkan dulu collection dan
environment yang dibutuhkan. Tutup semua tab halaman permintaan karena kita akan
mulai kembali dari awal.
Untuk membuat collection baru, silakan pilih tab Collection yang berada di samping
kiri.

Kemudian klik tombol “+” yang berada di samping kanannya.

Collection baru akan terbentuk dengan nama “New Collection''. Silakan ubah nama
dengan cara klik kanan -> Rename.

Ubah namanya menjadi “Notes API Test”.

Great! Jangan dulu tambahkan request yah, kita buat environment dulu dan
menggunakannya pada collection.

Silakan pilih tab Environment pada sidebar.

Klik Create a new Environment untuk membuat environment baru.

Ubah nama “New Environment” dengan “Notes API Test”, lalu tambahkan variabel baru
bernama noteId. Biarkan initial value dan current value tetap kosong.

Simpan perubahan dengan klik tombol Save.

Selanjutnya, gunakan Note API Test sebagai environment aktif.

Nice! Collection dan environment selesai kita siapkan. Selanjutnya mulai buat
request dan mengujinya di dalam collection.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Skenario Adding Notes

Kita mulai dengan skenario 1. Mari ingat kembali skenarionya.

Skenario 1: Adding Notes (Memasukkan catatan baru)

Pastikan response memiliki status code 201.

Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai yang sesuai.
Pastikan data pada response body memiliki noteId dan nilainya tidak kosong.
Yuk kita buat request baru di dalam collection Notes API Test.

Silakan buka tab Collections. Klik Add a request untuk menambahkan request.

Beri nama “Adding Notes” pada request kali ini.

Isi request URL dengan nilai localhost:5000/notes dan gunakan method POST.

Lalu, tambahkan data catatan yang akan ditambahkan pada Body. Silakan klik tab
Body, pilih opsi raw, kemudian ganti format text menjadi JSON, dan tuliskan
struktur JSON berikut:

{
"title": "Catatan A",
"tags": ["Android", "Web"],
"body": "Isi dari catatan A"
}
Eits! Jangan kirim request dulu ya. Kita akan tuliskan skenario testing untuk
request ini terlebih dahulu. Silakan pilih tab Tests..

Mulai tuliskan skenario testing di sini.

Postman memiliki global object pm. Untuk membuat testing, gunakan method pm.test().
Method tersebut menerima dua parameter, yang pertama nama test dan yang kedua
adalah spec function. Method test() mirip seperti method it() pada Jest (Anda sudah
mempelajarinya di kelas Belajar Dasar Pemrograman JavaScript).

Buat testing baru dengan nama ‘response status code should have 201 values’.

pm.test('response status code should have 201 value', () => {

});

Pastikan response status bernilai 201 dengan cara:

pm.test('response status code should have 201 value', () => {

pm.response.to.have.status(201);
});

Bila nanti respons status tidak memiliki nilai 201, maka tesnya akan gagal. Satu
testing telah dituliskan.

Lanjut tuliskan tes selanjutnya.

Buat test dengan nama ‘response Content-Type header should have application/json
value’.

pm.test('response Content-Type header should have application/json value', () => {

});

Kemudian uji nilai Content-Type pada response header dengan nilai application/json.

pm.test('response Content-Type header should have application/json value', () => {

pm.expect(pm.response.headers.get('Content-Type')).to.equals('application/json');
});

Kita lanjut ke tes selanjutnya.

Buat test dengan nama ‘response body should be an object’.

pm.test('response body should be an object', () => {

});

Kemudian dapatkan nilai response body dalam bentuk JSON dengan cara:

pm.test('response body should be an object', () => {

const responseJson = pm.response.json();
});

Selanjutnya uji responseJson bahwa ia harus merupakan sebuah objek. Caranya:

pm.test('response body should an object', () => {

const responseJson = pm.response.json();
pm.expect(responseJson).to.be.an('object');
});

Done!

Lanjut. Silakan buat testing baru bernama ‘response body should have the correct
property and value.’

pm.test('response body should have the correct property and value', () => {

});

Dapatkan response body dalam bentuk JSON dan uji kesesuaian properti serta nilai
atau tipe datanya.

pm.test('response body should have correct property and value', () => {

const responseJson = pm.response.json();
pm.expect(responseJson).to.ownProperty('status');
pm.expect(responseJson.status).to.equals('success');
pm.expect(responseJson).to.ownProperty('message');
pm.expect(responseJson.message).to.equals('Catatan berhasil ditambahkan');
pm.expect(responseJson).to.ownProperty('data');
pm.expect(responseJson.data).to.be.an('object');
});

Done!

Lanjut ke kriteria terakhir. Kita akan memastikan bahwa nilai data yang dibawa oleh
respons memiliki noteId dan nilainya tidaklah kosong.

Buat test baru dengan nama ‘response body data should have noteId property and not
equal to empty’.

pm.test('response body data should have noteId property and not equal to empty', ()
=> {

});

Di dalamnya, dapatkan nilai objek data dari response yang sudah diubah dengan
bentuk JSON.

pm.test('response body data should have noteId property and not equal to empty', ()
=> {
const responseJson = pm.response.json();
const { data } = responseJson;
});

Kemudian uji data bahwa ia harus memiliki properti noteId dan nilainya tidak
kosong.

pm.test('response body data should have noteId property and not equal to empty', ()
=> {
const responseJson = pm.response.json();
const { data } = responseJson;

pm.expect(data).to.ownProperty('noteId');
pm.expect(data.noteId).to.not.equals('');
});

Seperti yang kita ketahui, ketika permintaan menambahkan catatan baru, respons akan
mengembalikan noteId dari catatan baru tersebut. Simpanlah nilainya pada
environment variabel noteId agar nilainya dapat digunakan pada skenario pengujian
selanjutnya.

Untuk menyimpan nilai pada variabel environment, kita bisa gunakan method
pm.environment.set(). Method tersebut menerima dua parameter, yakni nama variabel
dan nilai yang akan ditetapkan padanya.

pm.test('response body data should have noteId property and not equal to empty', ()
=> {
const responseJson = pm.response.json();
const { data } = responseJson;

pm.expect(data).to.ownProperty('noteId');
pm.expect(data.noteId).to.not.equals('');

pm.environment.set('noteId', data.noteId);
});

Done! Pengujian pada skenario pertama selesai.

Sekarang coba kirim permintaan dengan klik tombol Send.

Lihat hasil uji pada kolom Test Result.

Wah! Ada satu pengujian yang gagal. Pesan eror mengatakan bahwa nilai Content-Type
bukanlah “application/json” (expectation) namun “application/json; charset=utf-8”
(actual).

Nilai actual sebenarnya adalah nilai yang kita ekspektasikan, namun karena kita
salah menetapkan nilai ekspektasi, maka pengujian gagal. Dengan begitu, Anda jadi
tahu kan bahwa pengujian otomatis ini sangat ketat, ia tidak akan mentoleransi bila
terjadi perbedaan sedikit pun antara nilai ekspektasi dan actual.

Untuk memperbaiki pengujian tersebut, kita perlu mengubah nilai ekspektasi menjadi
“application/json; charset=utf-8”.

pm.test('response Content-Type header should have application/json value', () => {

pm.expect(pm.response.headers.get('Content-Type')).to.equals('application/json;
charset=utf-8');
});

Silakan kirim kembali permintaan dengan klik tombol Send.

Woa! Sekarang seluruh hasil pengujian berhasil. Dengan begitu respons server dapat
dipastikan sesuai dengan yang Anda inginkan atau ekspektasikan.

Pastikan juga variabel noteId pada environment sudah terisi nilainya yah. Karena
variabel ini akan kita gunakan pada skenario testing selanjutnya.

Sebelum melanjutkan ke skenario berikutnya, jangan lupa untuk simpan request ini
dengan cara klik tombol Save.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Skenario Getting All Notes

Kita mulai skenario ke 2. Mari ingat-ingat kembali kriteria pengujiannya.
Skenario 2: Getting All Notes (Mendapatkan seluruh catatan)

Pastikan response memiliki status code 200.

Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai atau tipe data yang sesuai.
Pastikan data pada response body memiliki array notes dan terdapat minimal 1 item
di dalamnya.
Sudah siap? Yuk buat request baru pada collection Notes API Test.

Klik kanan pada Notes API Test collection dan pilih Add Request.

Kemudian beri nama request tersebut dengan “Getting All Notes”.

Isi request URL dengan localhost:5000/notes dan biarkan method tetap GET.

Kita tidak perlu melampirkan data apa pun pada request ini. Jadi, mari langsung
tuliskan kode pengujian pada tab Test.

Yuk mulai tuliskan testing pertama untuk menguji apakah response code bernilai 200.

Buat testing baru dengan nama “response status code should have 200 value”.

pm.test('response status code should have 200 value', () => {

});

Di dalamnya, lakukan uji nilai status code dengan nilai 200.

pm.test('response status code should have 200 value', () => {

pm.response.to.have.status(200);
});

Done!

Lanjut, buat testing baru dengan nama ‘response Content-Type header should have
application/json value’.

pm.test('response Content-Type header should have application/json value', () => {

});

Di dalamnya, uji nilai response header Content-Type dengan nilai “application/json;

charset=utf-8”. Anda sudah tahu bagaimana caranya kan?

pm.test('response Content-Type header should have application/json value', () => {

pm.expect(pm.response.headers.get('Content-Type')).to.equals('application/json;
charset=utf-8');
});

Done!

Lanjut, buat testing baru dengan nama ‘response body should an object’.

pm.test('response body should an object', () => {

});
Di dalamnya kita uji body respons haruslah sebuah object.

Pertama, kita dapatkan dulu nilai body respons dalam bentuk JSON.

pm.test('response body should an object', () => {

const responseJson = pm.response.json();
});

Kemudian uji responseJson, ia harus merupakan object.

pm.test('response body should an object', () => {

const responseJson = pm.response.json();
pm.expect(responseJson).to.be.an('object');
});

Done!

Lanjut. Silakan buat testing baru bernama ‘response body should have the correct
property and value’.

pm.test('response body should have the correct property and value', () => {

});

Di dalamnya, uji nilai response body yang merupakan object bahwa ia harus memiliki
properti dan nilai yang sesuai. Untuk melakukannya, tulis kode berikut:

pm.test('response body should have the correct property and value', () => {
const responseJson = pm.response.json();
pm.expect(responseJson).to.have.ownProperty('status');
pm.expect(responseJson.status).to.equals('success');
pm.expect(responseJson).to.have.ownProperty('data');
pm.expect(responseJson.data).to.be.an('object');
});

Done!

Lanjut ke pengujian terakhir, kita akan uji objek data yang ada di dalam response
body. Objek data harus memiliki array notes yang setidaknya memiliki 1 item note di
dalamnya.

Buat test dengan nama ‘response body data should have a notes array and contain at
least 1 item’.

pm.test('response body data should have a notes array and contain at least 1 item',
() => {

});

Di dalamnya, dapatkan objek data dari response body dalam bentuk JSON.

pm.test('response body data should have a notes array and contain at least 1 item',
() => {
const responseJson = pm.response.json();
const { data } = responseJson;
});

Kemudian uji nilai objek data bahwa ia harus memiliki properti notes yang merupakan
array dan minimal memiliki 1 item di dalamnya.
pm.test('response body data should have a notes array and contain at least 1 item',
() => {
const responseJson = pm.response.json();
const { data } = responseJson;

pm.expect(data).to.have.ownProperty('notes');
pm.expect(data.notes).to.be.an('array');
pm.expect(data.notes).lengthOf.at.least(1);
});

Skenario ke-2 selesai!

Sekarang kita kirim permintaan dengan klik tombol Send dan lihat hasil
pengujiannya.

Nice! Response yang dihasilkan server sesuai dengan ekspektasi kita.

Simpan request ini dengan klik tombol Save dan kita lanjutkan ke skenario
berikutnya.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Skenario Getting Specified Note

Kita lanjutkan ke skenario pengujian ke-3 yaitu mendapatkan catatan secara spesifik
berdasarkan noteId yang berada di variable environment. Sebelum itu, kita ingat-
ingat kembali kriteria dari skenario ini.

Skenario 3: Getting Specified Note (Mendapatkan catatan secara spesifik)

Pastikan response memiliki status code 200.

Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response merupakan object.
Pastikan body response memiliki properti dan nilai atau tipe data yang sesuai.
Pastikan data pada response body memiliki properti note yang merupakan sebuah
objek.
Pastikan objek note di dalam data memiliki properti id, title, body, dan tags
dengan nilai yang sesuai.
Sudah siap? Yuk kita buat request baru di dalam Notes API Test. Beri nama request
tersebut dengan “Getting Specified Note”.

Pada request URL isikan nilai localhost:5000/notes/{{noteId}} dan biarkan method

yang digunakan tetap GET.

Seperti yang sudah Anda ketahui, {{noteId}} merupakan nilai yang diambil dari
environment variabel. Di mana variabel tersebut terisi nilainya ketika kita
melakukan permintaan memasukkan catatan baru.

Sekarang yuk kita mulai tuliskan saja pengujian pada tab Tests.

Seperti biasa, pertama kita buat test untuk menguji status code dari respons dengan
nama “response status code should have 200 value”.

pm.test('response status code should have 200 value', () => {

});
Uji status code dengan nilai 200.

pm.test('response status code should have 200 value', () => {

pm.response.to.have.status(200);
});

Done!

Lanjut, buat testing baru dengan nama ‘response Content-Type header should have
application/json value’.

pm.test('response Content-Type header should have application/json value', () => {

});

Seperti biasa, di dalamnya kita uji response header Content-Type dengan nilai
“application/json; charset=utf-8”.

pm.test('response Content-Type header should have application/json value', () => {

pm.expect(pm.response.headers.get('Content-Type')).to.equals('application/json;
charset=utf-8');
});

Lanjut buat tes baru dengan nama “response body should be an object”.

pm.test('response body should be an object', () => {

});

Dapatkan nilai response body dalam bentuk JSON.

pm.test('response body should be an object', () => {

const responseJson = pm.response.json();
});

Kemudian uji responseJson, ia adalah sebuah objek.

pm.test('response body should be an object', () => {

const responseJson = pm.response.json();
pm.expect(responseJson).to.be.an('object');
});

Done!

Lanjut kita uji objek response body-nya, ia harus memiliki properti yang sesuai.
Buat test baru dengan nama “response body should have the correct property and
value”.

pm.test('response body should have the correct property and value', () => {

});

Dapatkan response body dalam bentuk JSON.

pm.test('response body should have the correct property and value', () => {
const responseJson = pm.response.json();
});

Lalu uji responseJson, ia harus memiliki properti status dengan nilai success dan
data yang merupakan object.

pm.test('response body should have the correct property and value', () => {
const responseJson = pm.response.json();

pm.expect(responseJson).to.have.ownProperty('status');
pm.expect(responseJson.status).to.equals('success');
pm.expect(responseJson).to.have.ownProperty('data');
pm.expect(responseJson.data).to.be.an('object');
});

Done!

Lanjut uji object data dari response body bahwa ia harus memiliki properti note
yang merupakan sebuah objek.

Buat test baru dengan nama “'response body data should contain note object”.

pm.test('response body data should contain note object', () => {

});

Dapatkan objek data dari response body dalam bentuk JSON.

pm.test('response body data should contain note object', () => {

const responseJson = pm.response.json();
const { data } = responseJson;
});

Uji objek data bahwa ia harus memiliki properti note yang merupakan sebuah objek.

pm.test('response body data should contain note object', () => {

const responseJson = pm.response.json();
const { data } = responseJson;

pm.expect(data).to.have.ownProperty('note');
pm.expect(data.note).to.be.an('object');
});

Done!

Lanjut ke pengujian terakhir. Kita akan uji objek note, ia harus memiliki properti
id, title, body, dan tags. Properti-properti tersebut harus memiliki nilai yang
sesuai dengan nilai yang dimasukan pada skenario pertama.

Buat test baru dengan nama “note object should contain correct value for id, title,
body, and tags property”.

pm.test('note object should contain correct value for id, title, body, and tags
property', () => {

});

Di dalamnya, dapatkan objek note dari data di dalam response body.

pm.test('note object should contain correct value for id, title, body, and tags
property', () => {
const responseJson = pm.response.json();
const { data: { note } } = responseJson;
});

Sebelum menguji properti dan nilai di dalam objek note, tentukan dulu nilai
ekspektasi dari id, title, body, dan tags. Nilai id bisa Anda dapatkan dari
variabel environment melalui method pm.environment.get(‘noteId’), sedangkan yang
lain Anda bisa lihat nilainya pada request Adding Notes yang dikirimkan melalui
body.

Yuk kita buat dulu nilai ekspektasinya.

pm.test('note object should contain correct value for id, title, body, and tags
property', () => {
const responseJson = pm.response.json();
const { data: { note } } = responseJson;

const expectedId = pm.environment.get('noteId');

const expectedTitle = 'Catatan A';
const expectedTags = ['Android', 'Web'];
const expectedBody = 'Isi dari catatan A';
});

Setelah menentukan nilai ekspektasi, barulah kita uji objek note bahwa ia harus
memiliki properti dan nilai yang sesuai dengan nilai ekspektasi.

pm.test('note object should contain correct value for id, title, body, and tags
property', () => {
const responseJson = pm.response.json();
const { data: { note } } = responseJson;
const expectedId = pm.environment.get('noteId');
const expectedTitle = 'Catatan A';
const expectedTags = ['Android', 'Web'];
const expectedBody = 'Isi dari catatan A';
pm.expect(note).to.have.ownProperty('id');
pm.expect(note.id).to.equals(expectedId);
pm.expect(note).to.have.ownProperty('title');
pm.expect(note.title).to.equals(expectedTitle);
pm.expect(note).to.have.ownProperty('tags');
pm.expect(note.tags).to.equals(expectedTags);
pm.expect(note).to.have.ownProperty('body');
pm.expect(note.body).to.equals(expectedBody);
});

Done!

Yuk kita kirim permintaan. Silakan klik tombol Send, kemudian lihat hasil
pengujiannya.

Oh tidak! Ada satu pengujian yang gagal, pesannya:

AssertionError: expected [ 'Android', 'Web' ] to equal [ 'Android', 'Web' ]

Apa yang salah ya? Bila dilihat sih nilai expected dan actual sudah sama persis.
Lalu apa yang menyebabkan ia eror?

Ketahuilah bahwa untuk menguji nilai array dan objek, kita tidak bisa menggunakan
method equals() seperti yang biasa kita gunakan. Itu karena array dan objek tidak
bisa disamakan secara identik walaupun ia memiliki item atau properti dan nilai
yang sama persis. Anda bisa membuktikan ini dengan menjalankan kode berikut pada
node REPL:
["Harry", "Potter"] === ["Harry", "Potter"]
// -> false

{ firstName: "Harry", lastName: "Potter" } === { firstName: "Harry", lastName:

"Potter" }
// -> false

Lalu bagaimana solusinya? Bagaimana cara kita menguji nilai array?

Caranya adalah dengan melakukan deep equals. Deep equals paling sederhana dapat
dilakukan menggunakan bantuan JSON.stringify. Lebih jelasnya, kedua objek atau
array yang akan diuji diubah menjadi JSON string, kemudian kedua JSON string
tersebutlah yang akan diuji nilainya.

JSON.stringify(["Harry", "Potter"]) === JSON.stringify(["Harry", "Potter"]);

// -> true

JSON.stringify({ firstName: "Harry", lastName: "Potter" }) ===

JSON.stringify({ firstName: "Harry", lastName: "Potter" });
// -> true

Cukup mudah ‘kan? Bahkan, akan lebih mudah lagi untuk melakukan deep equal pada
pengujian di Postman karena kita tidak perlu repot mengubah nilai ekspektasi dan
actual ke JSON string. Cukup ganti penggunaan method equals() ke eql().

pm.test('note object should contain correct value for id, title, body, and tags
property', () => {
const responseJson = pm.response.json();
const { data: { note } } = responseJson;

const expectedId = pm.environment.get('noteId');

const expectedTitle = 'Catatan A';
const expectedTags = ['Android', 'Web'];
const expectedBody = 'Isi dari catatan A';

pm.expect(note).to.have.ownProperty('id');
pm.expect(note.id).to.equals(expectedId);

pm.expect(note).to.have.ownProperty('title');
pm.expect(note.title).to.equals(expectedTitle);

pm.expect(note).to.have.ownProperty('tags');
pm.expect(note.tags).to.eql(expectedTags);

pm.expect(note).to.have.ownProperty('body');
pm.expect(note.body).to.equals(expectedBody);
});

Kirim kembali permintaan dengan menekan Send.

Voila! Sekarang seluruh pengujian berhasil dijalankan. Jangan lupa simpan request
kali ini dengan menekan tombol Save sebelum melanjutkan ke skenario selanjutnya.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Skenario Update Note

Selanjutnya kita tulis pengujian untuk skenario ke-4, yakni memperbaharui data
catatan. Seperti biasa, kita ingat-ingat dulu kriteria pengujiannya yah.

Skenario 4: Update Note (Memperbarui data catatan)

Pastikan response memiliki status code 200.

Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai yang sesuai.
Ketika mengakses catatan yang diperbaharui
Pastikan catatan yang diperbarui memiliki nilai terbaru.
Sudah mantap? Yuk kita mulai tuliskan pengujiannya.

Buat request baru di dalam collection dengan nama “Update Note”.

Pada request URL, isikan nilai localhost:5000/notes/{{noteId}} dan ubah method yang
digunakan menjadi PUT.

Sebelum menuliskan tes, sisipkan dulu data catatan terbaru pada body request.
Silakan pilih tab Body, kemudian pilih raw, dan ubah tipenya menjadi JSON.

Kemudian tulis JSON berikut pada body request.

{
"title": "Catatan A Revised",
"tags": ["Android", "Web"],
"body": "Isi dari Catatan A Revised"
}

Data sudah siap! Lanjut pilih tab Tests untuk mulai menuliskan pengujian.

Seperti biasa, pengujian pertama kita uji status code dari respons. Silakan buat
test dengan nama “response status code should have 200 value”.

pm.test('response status code should have 200 value', () => {

});

Di dalamnya, uji response code dengan nilai 200.

pm.test('response status code should have 200 value', () => {

pm.response.to.have.status(200);
});

Done!

Lanjut kita uji nilai Content-Type yang ada pada response. Silakan buat test baru
dengan nama “‘response Content-Type header should have application/json value”.

pm.test('response Content-Type header should have application/json value', () => {

});

Seperti biasa, di dalamnya kita uji response header Content-Type dengan nilai
“application/json; charset=utf-8”.

pm.test('response Content-Type header should have application/json value', () => {

pm.expect(pm.response.headers.get('Content-Type')).to.equals("application/json;
charset=utf-8");
});

Done!

Selanjutnya kita uji body response bahwa ia harus merupakan sebuah objek. Silakan
buat test baru dengan nama “‘response body should be an object”.

pm.test('response body should be an object', () => {

});

Di dalamnya, dapatkan nilai response body sebagai JSON objek.

pm.test('response body should be an object', () => {

const responseJson = pm.response.json();
});

Kemudian, uji responseJson bahwa ia harus sebuah objek.

pm.test('response body should be an object', () => {

const responseJson = pm.response.json();
pm.expect(responseJson).to.be.an('object');
});

Done!

Lanjut, uji nilai objek body response-nya. Buat test baru dengan nama “‘response
body should have correct properti and value”.

pm.test('response body should have correct property and value', () => {

});

Di dalamnya, dapatkan nilai body response dalam bentuk JSON objek.

pm.test('response body should have correct property and value', () => {

const responseJson = pm.response.json();
});

Kemudian uji responseJson, ia harus memiliki properti dan nilai yang sesuai.

pm.test('response body should have correct property and value', () => {

const responseJson = pm.response.json();

pm.expect(responseJson).to.have.ownProperty('status');
pm.expect(responseJson.status).to.equals('success');
pm.expect(responseJson).to.have.ownProperty('message');
pm.expect(responseJson.message).to.equals('Catatan berhasil diperbarui');
});

Done!

Terakhir, bagaimana cara memastikan catatan yang diperbaharui memiliki nilai

terbaru? Tentu caranya adalah dengan melakukan permintaan untuk mendapatkan catatan
secara spesifik.

Karena kita sudah menguji dan memastikan bahwa permintaan tersebut berjalan dengan
baik melalui skenario ke-3, sekarang kita bisa percaya diri dalam menggunakannya
untuk memastikan data catatan pada skenario ini benar-benar telah diperbaharui.
Yuk buat test baru dengan nama “when request the updated note”.

pm.test('when request the updated note', () => {

});

Di dalamnya, kita lakukan permintaan untuk mendapatkan catatan secara spesifik

berdasarkan id.

Dapatkan dulu nilai noteId dari environment variable.

pm.test('when request the updated note', () => {

const noteId = pm.environment.get('noteId');
});

Lalu buatlah request ke http://localhost:5000/notes/${notesId} dengan menggunakan

method pm.sendRequest().

pm.test('when request the updated note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
});
});

Anda bisa lihat kode request di atas, method sendRequest() menerima dua parameter,
yakni request URL dan fungsi response callback. Response callback akan terpanggil
ketika permintaan sudah ditanggapi oleh response ataupun mengalami eror.

Eror dapat terjadi karena berbagai hal, salah satunya tidak adanya internet. Ketika
eror, parameter error yang berada di response callback akan terisi nilainya. Namun
bila permintaan berhasil dilakukan dan mendapatkan response dari server, maka
parameter response-lah yang terisi nilainya.

Pola ini disebut dengan error first, di mana callback function mendahulukan
parameter error dibandingkan dengan ketika operasi berhasil dijalankan. Node.js
banyak menerapkan pola ini pada sebuah fungsi callback.

Yuk kita lanjutkan. Di dalam fungsi callback, kita buat test baru dengan nama “then
the updated note should contain the latest data” untuk menguji nilai dari body
response. Namun ingat, lakukan hal tersebut bila nilai error tidak terisi saja.

pm.test('when request the updated note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
if(!error) {
pm.test('then the updated note should contain the latest data', () => {

});
}
});
});

Selanjutnya di dalam test tersebut, kita dapatkan nilai objek note pada data
melalui response body dalam bentuk JSON.

pm.test('when request the updated note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
 if(!error) {
pm.test('then the updated note should contain the latest data', () => {
const responseJson = response.json();
const { data: { note } } = responseJson;
});
}
});
});

Sebelum menguji properti dan nilai dari objek note, tentukan nilai ekspektasi dari
title, tags, dan body. Bila Anda lupa, Anda bisa lihat pada body request Update
Note.

pm.test('when request the updated note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
if(!error) {
pm.test('then the updated note should contain the latest data', () => {
const responseJson = response.json();
const { data: { note } } = responseJson;

const expectedTitle = 'Catatan A Revised';

const expectedTags = ['Android', 'Web'];
const expectedBody = 'Isi dari Catatan A Revised';
});
}
});
});

Nice! Sekarang kita uji nilai dari properti title, tags, dan body yang dimiliki
objek note dengan nilai ekspektasi.

pm.test('when request the updated note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
if(!error) {
pm.test('then the updated note should contain the latest data', () => {
const responseJson = response.json();
const { data: { note } } = responseJson;

const expectedTitle = 'Catatan A Revised';

const expectedTags = ['Android', 'Web'];
const expectedBody = 'Isi dari Catatan A Revised';

pm.expect(note.title).to.equals(expectedTitle);
pm.expect(note.tags).to.eql(expectedTags);
pm.expect(note.body).to.equals(expectedBody);
});
}
});
});

Skenario 4 selesai! Yuk kita coba kirim permintaan dengan klik tombol Send.

Boom! Seluruh pengujian berhasil dijalankan.

Simpan request dengan menekan tombol Save dan ayo kita lanjutkan ke skenario
terakhir.
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Skenario Delete Note

Kita menuju skenario terakhir yaitu menghapus catatan. Seperti biasa, yuk kita
ingat-ingat kembali kriterianya.

Skenario 5: Delete Note (Menghapus catatan)

Pastikan response memiliki status code 200.

Pastikan header response Content-Type memiliki nilai application/json.
Pastikan body response adalah object.
Pastikan body response memiliki properti dan nilai yang sesuai.
Ketika mengakses catatan yang dihapus
Pastikan catatan yang dihapus tidak ditemukan.
Sudah siap? Ayo kita mulai!

Buat request baru di dalam collection dengan nama “Delete Note”.

Kemudian pada request URL, isi dengan nilai localhost:5000/notes/{{noteId}} dan

ubah method yang digunakan menjadi DELETE.

Kita tidak perlu melampirkan data apa pun pada body request. Jadi langsung saja
menuju tab Tests untuk mulai menuliskan pengujian.

Tak bosan-bosan, pertama kita buat pengujian untuk menguji status code dengan nilai
200. Silakan buat test dengan nama “response status code should have 200 value”.

pm.test('response status code should have 200 value', () => {

});

Di dalamnya, uji response status code dengan nilai 200.

pm.test('response status code should have 200 value', () => {

pm.response.to.have.status(200);
});

Done!

Lanjut buat tes dengan nama “‘response Content-Type header should have
application/json value”.

pm.test('response Content-Type header should have application/json value', () => {

});

Seperti biasa, di dalamnya kita uji response header Content-Type dengan nilai
“application/json; charset=utf-8”.

pm.test('response Content-Type header should have application/json value', () => {

pm.expect(pm.response.headers.get('Content-Type')).to.equals('application/json;
charset=utf-8')
});

Selanjutnya kita uji body response bahwa ia haruslah objek. Silakan buat test baru
dengan nama “‘response body should be an object”.
pm.test('response body should be an object', () => {

});

Di dalamnya, dapatkan nilai response body sebagai JSON objek.

pm.test('response body should be an object', () => {

const responseJson = pm.response.json();
});

Kemudian, uji responseJson bahwa ia harus sebuah objek.

pm.test('response body should be an object', () => {

const responseJson = pm.response.json();
pm.expect(responseJson).to.be.an('object');
});

Done!

Lanjut uji nilai objek body response-nya. Buat test baru dengan nama “‘response
body should have correct properti and value”.

pm.test('response body should have correct property and value', () => {

});

Di dalamnya, dapatkan nilai body response dalam bentuk JSON objek.

pm.test('response body should have correct property and value', () => {

const responseJson = pm.response.json();
});

Kemudian, uji responseJson bahwa ia harus memiliki properti dan nilai yang sesuai.

pm.test('response body should have correct property and value', () => {

const responseJson = pm.response.json();

pm.expect(responseJson).to.have.ownProperty('status');
pm.expect(responseJson.status).to.equals('success');
pm.expect(responseJson).to.have.ownProperty('message');
pm.expect(responseJson.message).to.equals('Catatan berhasil dihapus');
});

Done!

Terakhir, kita akan melakukan hal yang sama seperti skenario sebelumnya. Untuk
memastikan catatan benar-benar dihapus oleh server, kita akan melakukan permintaan
kepada catatan tersebut. Server harus mengembalikan response dengan status code 404
dan objek body yang relevan dengan status tersebut.

Yuk kita buat test baru dengan nama “when request the deleted note”.

pm.test('when request the deleted note', () => {

});

Di dalamnya, lakukan request ke http://localhost:5000/notes/${noteId}. Nilai noteId

kita dapatkan dari environment variable.
pm.test('when request the deleted note', () => {
const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
});
});

Di dalam fungsi callback response, bila parameter error tidak memiliki nilai,
silakan buat test dengan nama “the deleted note should be not found”.

pm.test('when request the deleted note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
if(!error) {
pm.test('the deleted note should be not found', () => {
});
}
});
});

Di dalam test tersebut, uji status code response dengan nilai 404.

pm.test('when request the deleted note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
if(!error) {
pm.test('the deleted note should be not found', () => {
pm.expect(response.code).to.equals(404);
});
}
});
});

Anda bisa uji juga nilai body pada response. Pastikan ia memiliki properti dan
nilai yang relevan dengan status code-nya.

pm.test('when request the deleted note', () => {

const noteId = pm.environment.get('noteId');
pm.sendRequest(`http://localhost:5000/notes/${noteId}`, (error, response) => {
if(!error) {
pm.test('the deleted note should be not found', () => {
pm.expect(response.code).to.equals(404);
const responseJson = response.json();
pm.expect(responseJson.status).to.equals('fail');
pm.expect(responseJson.message).to.equals('Catatan tidak
ditemukan');
});
}
});
});

Done!

Skenario pengujian terakhir selesai kita tuliskan! Silakan kirim permintaan dengan
klik tombol Send. Lihat hasil pengujiannya.

Boom! Semuanya hijau.

Jangan lupa untuk menyimpan request dengan klik tombol Save.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Menjalankan Seluruh Permintaan pada Collection

Selamat yah Anda sudah berhasil menuliskan automate testing menggunakan Postman.
Melalui automate testing ini diharapkan Anda tidak perlu lagi memeriksa hasil
response secara manual ketika mengirimkan permintaan menggunakan Postman. Pengujian
yang sudah Anda buat bisa menjadi patokan keberhasilan fungsionalitas API ketika
ingin mengembangkan API ini kedepannya. Anda tidak perlu khawatir untuk mengotak-
atik kode yang membuat fungsionalitas api gagal. Selama pengujiannya berhasil,
fungsionalitas API dapat dipastikan tetap aman.

Saat ini Anda memiliki lima skenario request pada collection.

Keuntungan mengelompokkan permintaan menggunakan collection adalah Anda bisa

menjalankan permintaan-permintaan secara berurutan dengan sekali klik. Caranya,
pilih collection Notes API Test.

Kemudian klik tombol Run seperti gambar di atas.

Pastikan urutan permintaannya benar. Awali permintaan dengan skenario menambahkan

catatan, mendapatkan seluruh catatan, mendapatkan catatan secara spesifik, mengubah
catatan, dan terakhir menghapus catatan.

Setelah urutannya sesuai, klik tombol Run Notes API Test.

Anda bisa lihat hasil permintaan serta pengujiannya seketika. Praktis bukan?

Catatan
Mulai dari Maret 2023, pengguna gratis Postman versi 10.x.x memiliki batasan dalam
menjalankan Postman Collection melalui UI sebanyak 25 kali dalam sebulan. Jika Anda
sudah mencapai batasan tersebut, tetapi masih perlu menjalankan collection,
terdapat dua solusi yang bisa Anda ambil.

(Rekomendasi) Jalankan Postman Collection secara terprogram menggunakan Postman CLI

atau Newman.
Gunakan Postman versi 9 stabil yang dapat diunduh melalui tautan:
Windows
Linux
macOS
Ke depannya Anda bisa tambahkan permintaan dengan skenario lain, termasuk skenario
negatif. Contohnya permintaan untuk meng-update note namun dengan id yang tidak
ditemukan; menambahkan catatan namun tanpa melampirkan data body apa pun; atau
skenario lainnya. Dengan begitu, API yang Anda buat dapat dipastikan berfungsi
sesuai yang dikehendaki.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------

Menjalankan Postman Collection secara Terprogram dengan Newman

Di materi sebelumnya, Anda sudah berhasil menjalankan Postman Collection dengan
menggunakan collection runner yang disediakan oleh aplikasi Postman. Ketahuilah
bahwa selain dengan aplikasi Postman, Anda juga bisa menjalankan Postman Collection
secara terprogram tanpa perlu mengakses UI aplikasi Postman dengan menggunakan
Newman.

Menjalankan Postman Collection secara terprogram sangat berguna untuk mengotomasi

proses pengujian. Pasalnya, Anda tidak bergantung terhadap interaksi pengguna
seperti klik tombol melainkan cukup dengan perintah CLI.

Persiapan sebelum menjalankan Postman Collection dengan Newman

Di materi sebelumnya, kita sudah membuat Postman Collection bernama “Notes API
Test” lengkap dengan pengujian di dalamnya. Selain Postman Collection, kita juga
sudah membuat Postman Environment untuk kebutuhan environment variable selama
pengujian berjalan.

Dengan Newman, kita bisa menjalankan Postman Collection tanpa perlu berinteraksi
dengan aplikasi Postman. Namun, sebelum kita bisa menggunakan Newman, kita perlu
mengekspor Postman Collection dan Postman Environment menjadi sebuah berkas JSON.
Ikuti langkah-langkah berikut untuk mengekspor Postman Collection dan Postman
Environment.

Pertama, buka aplikasi Postman dan pilih Collection bernama “Notes API Test” hingga
tampak tampilan seperti gambar di bawah ini.

Selanjutnya, klik tombol titik tiga . . ., kemudian pilih opsi Export.

Aplikasi akan menampilkan Pop-up Export Collection. Pilih opsi Collection v2.1
sebagai format berkas JSON dan klik tombol Export untuk memulai proses ekspor.

Agar mudah dalam menjalankan pengujiannya kelak, kami sarankan untuk simpan berkas
hasil ekspor di folder proyek notes-app-back-end dan sesuaikan nama berkasnya
menjadi notes-api-test.postman_collection.json.

Proses ekspor Postman Collection selesai! Selanjutnya kita perlu mengekspor juga
Postman Environment.

Kembali lagi ke aplikasi Postman dan pilih environment Notes API Test.

Selanjutnya, klik tombol titik tiga . . ., kemudian pilih opsi Export.

Sama seperti berkas Postman Collection, kami merekomendasikan untuk menyimpan

berkasnya di dalam folder proyek notes-app-back-end dan ubah nama berkas menjadi
notes-api-test.postman_environment.json.

Memasang Newman dan Menjalankan Postman Collection

Setelah kita memiliki berkas JSON dari Postman Collection dan Postman Environment
kita bisa mulai beranjak untuk menjalankannya menggunakan Newman. Ikuti langkah-
langkah dari mulai memasang Newman dan menjalankan Postman Collection.

Newman merupakan aplikasi dalam bentuk binary yang dijalankan via CLI. Untuk
menggunakan Newman, kita perlu mengunduh dan memasang binary tersebut. Berutunglah
karena binary Newman dapat diunduh dan dipasang dengan mudah dengan menggunakan
JavaScript Package Manager, seperti npm dan yarn.

Untuk memasang Newman menggunakan npm, pasanglah package newman secara global
dengan perintah.

npm install newman --g

Tunggu hingga npm berhasil memasang package newman.

Setelah berhasil terpasang perintah newman harusnya tersedia pada Terminal,

Powershell, atau CMD di komputer Anda.

Oke. Selanjutnya kita akan menjalankan berkas Postman Collection dengan menggunakan
Newman. Agar mudah dalam menjalankannya, Anda bisa manfaatkan Terminal yang ada di
VSCode karena berkas Postman Collection dan Postman Environment ada di dalam folder
proyek notes-app-back-end.

Bukalah proyek notes-app-back-end dan siapkan bilah Terminal.

Sebelum menjalankan Postman Collection, pastikan web server sedang berjalan. Jika
tidak, jalankan dulu dengan perintah berikut ini.

npm run start-dev

Setelah web server dipastikan berjalan, selanjutnya kita bisa jalankan Postman
Collection dengan Newman melalui perintah di bawah ini.

newman run notes-api-test.postman_collection.json --environment notes-api-

test.postman_environment.json

Catatan: Anda bisa membuka Terminal lebih dari satu pada VSCode dengan menekan
tombol + pada bilah Terminal.

Hasilnya akan tampak seperti berikut.