- Apa itu Testing & QA?
- Tingkatan Pengujian: Unit, Integration, End-to-End
- Struktur Test Pyramid
- Otomatisasi & Pengujian di Pipeline CI
- Metodologi QA
- Keandalan Software (Reliability)
- Pelacakan Bug
- Siapa itu QA Engineer?
- Bagaimana Bug Ditemukan hingga Diperbaiki?
- Perjalanan Testing & QA (1947βSekarang)
- Tools Testing & QA
1. APA ITU TESTING & QA?
- Software testing adalah proses menjalankan dan memeriksa software untuk menemukan kesalahan (bug) sebelum ditemukan oleh pengguna.
- Glenford Myers dalam buku The Art of Software Testing (1979) mendefinisikannya sebagai "proses menjalankan program dengan tujuan menemukan error". Definisi ini masih dipakai hingga sekarang.
- Edsger Dijkstra (1970) mengingatkan: "Testing dapat menunjukkan adanya bug, tetapi tidak pernah dapat membuktikan bahwa bug tidak ada."
- Ada tiga istilah yang sering tertukar:
- Quality Assurance (QA) β proses untuk mencegah bug sejak awal: standar, review, dan alur kerja tim
- Quality Control (QC) β pemeriksaan produk untuk menemukan cacat sebelum dirilis
- Testing β aktivitas teknis menjalankan pengujian, bagian dari QC
- Berdasarkan cara pelaksanaannya, testing dibagi menjadi dua:
- Manual Testing β dijalankan langsung oleh manusia, cocok untuk eksplorasi dan pengalaman pengguna
- Automated Testing β dijalankan oleh kode secara otomatis, cocok untuk pengujian berulang
2. TINGKATAN PENGUJIAN
- Pengujian dilakukan bertingkat, dari bagian terkecil hingga sistem utuh.
- Pengujian fungsional memeriksa apakah fitur bekerja sesuai kebutuhan, sedangkan pengujian non-fungsional memeriksa performa, keamanan, dan kemudahan pemakaian.
- Tingkatan pengujian yang paling umum adalah:
- Unit Testing
- Integration Testing
- End-to-End (E2E) & Acceptance Testing
UNIT TESTING - TINGKATAN PENGUJIAN
- Unit test menguji bagian terkecil kode, seperti satu fungsi atau satu class, secara terpisah dari bagian lain.
- Berjalan sangat cepat (milidetik) sehingga bisa dijalankan ratusan kali sehari.
- Akarnya adalah SUnit untuk Smalltalk buatan Kent Beck, lalu JUnit (Kent Beck & Erich Gamma, 1997) yang melahirkan keluarga xUnit: PHPUnit, pytest, NUnit, dan lainnya.
- Ketergantungan seperti database atau API luar diganti dengan tiruan (mock, stub, fake) agar test fokus pada logika saja.
- Pola penulisan yang umum adalah AAA: Arrange (siapkan data), Act (jalankan fungsi), Assert (periksa hasil).
Contoh unit test dengan Jest (JavaScript). Perhatikan pengujian tepat di batas nilai 100.000:
Kode:
// diskon.js
function hitungDiskon(total) {
if (total >= 100000) return total * 0.1;
return 0;
}
// diskon.test.js
test("diskon 10% untuk belanja minimal 100 ribu", () => {
expect(hitungDiskon(100000)).toBe(10000);
});
test("tidak ada diskon di bawah 100 ribu", () => {
expect(hitungDiskon(99999)).toBe(0);
});
INTEGRATION TESTING - TINGKATAN PENGUJIAN (LANJUTAN)
- Integration test memeriksa apakah beberapa bagian bekerja dengan benar ketika digabungkan, misalnya kode dengan database, atau layanan dengan API lain.
- Banyak bug muncul bukan di dalam satu fungsi, tetapi di "sambungan" antar bagian: format data berbeda, query salah, atau konfigurasi keliru.
- Saat ini integration test sering memakai database asli yang dijalankan sementara di container, misalnya dengan Testcontainers (2015).
- Pada microservices dikenal contract testing (misalnya Pact, 2013) untuk memastikan kesepakatan format API antar layanan tidak dilanggar.
END-TO-END & ACCEPTANCE TESTING - TINGKATAN PENGUJIAN (LANJUTAN)
- End-to-End test menguji alur lengkap seperti yang dilakukan pengguna, misalnya: buka website, login, tambah produk ke keranjang, lalu checkout.
- Dijalankan di browser sungguhan oleh tool seperti Selenium (2004), Cypress (2017), atau Playwright (2020).
- Paling mendekati kondisi nyata, tetapi lambat, mahal dirawat, dan mudah gagal karena hal kecil.
- User Acceptance Testing (UAT) dilakukan oleh klien atau pengguna untuk memastikan software sesuai kebutuhan bisnis sebelum resmi dipakai.
- Pengujian non-fungsional melengkapinya: performance/load testing (JMeter, k6), security testing, dan usability testing.
3. STRUKTUR TEST PYRAMID
Kode:
/\
/ \ E2E Test: sedikit, lambat, mahal
/----\
/ \
/ \ Integration Test: jumlah sedang
/----------\
/ \
/ \ Unit Test: banyak, cepat, murah
/----------------\
Test Pyramid diperkenalkan oleh Mike Cohn (2009): semakin ke atas, test semakin lambat dan mahal, sehingga jumlahnya dibuat semakin sedikit. Pada tahun 2018 Kent C. Dodds memperkenalkan variasi Testing Trophy yang memberi porsi lebih besar pada integration test untuk aplikasi web modern. Keduanya sepakat pada satu hal: jangan bergantung hanya pada E2E test.
4. OTOMATISASI & PENGUJIAN DI PIPELINE CI
- Continuous Integration (CI) adalah praktik menggabungkan kode ke repositori utama sesering mungkin, dan setiap penggabungan otomatis di-build serta diuji.
- Istilah ini digunakan Grady Booch (1991), lalu dipopulerkan Extreme Programming dan artikel Martin Fowler (2000).
- Tujuannya agar bug ketahuan beberapa menit setelah kode ditulis, bukan beberapa minggu kemudian.
- Pipeline CI biasanya berjalan setiap kali developer melakukan push atau membuka Pull Request.
- Tool CI yang umum: Jenkins (penerus Hudson, 2011), GitLab CI, dan GitHub Actions (2019).
Kode:
[ Developer push kode / membuka Pull Request ]
β
βΌ
1. Lint & Format Check β gaya kode & error sederhana
β
βΌ
2. Build β kode bisa dikompilasi
β
βΌ
3. Unit Test β selesai dalam hitungan detik
β
βΌ
4. Integration Test β database & API di container
β
βΌ
5. E2E Test & Security Scan β alur utama & celah keamanan
β
βΌ
[ Semua lulus? ]
βββ Ya β boleh merge, lalu deploy ke staging
βββ Tidak β pipeline gagal, developer diberi tahu
PRAKTIK OTOMATISASI YANG BAIK - PIPELINE CI (LANJUTAN)
- Pipeline harus cepat: jalankan test paling cepat lebih dulu agar umpan balik segera diterima.
- Jangan merge jika pipeline merah: aktifkan branch protection agar kode yang gagal test tidak bisa masuk ke branch utama.
- Atasi flaky test: test yang kadang lulus kadang gagal tanpa perubahan kode. Jika dibiarkan, tim berhenti percaya pada hasil test.
- Code coverage hanyalah petunjuk: coverage 100% tidak menjamin bebas bug. Yang penting, bagian kritis benar-benar diuji.
- Regression test: setiap bug yang diperbaiki dibuatkan test agar bug yang sama tidak muncul kembali.
5. METODOLOGI QA
- Metodologi QA menentukan kapan dan bagaimana pengujian dilakukan dalam proses pengembangan.
- Barry Boehm (1981) menunjukkan bahwa biaya memperbaiki bug berlipat-lipat semakin terlambat bug ditemukan. Prinsip ini menjadi dasar semua metodologi modern.
- Metodologi yang umum digunakan adalah:
- Waterfall & V-Model
- Agile Testing & Shift-Left
- TDD & BDD
WATERFALL & V-MODEL - METODOLOGI QA
- Pada Waterfall (digambarkan Winston Royce, 1970), testing dilakukan di akhir setelah semua kode selesai, sehingga bug sering ditemukan terlambat.
- V-Model (dikenal sejak 1980-an) memasangkan setiap tahap pengembangan dengan tahap pengujiannya: kebutuhan dengan acceptance test, desain sistem dengan system test, desain modul dengan unit test.
- Masih dipakai di industri yang sangat ketat seperti alat kesehatan, otomotif, dan penerbangan.
AGILE TESTING & SHIFT-LEFT - METODOLOGI QA (LANJUTAN)
- Sejak Agile Manifesto (2001), testing dilakukan terus-menerus di setiap sprint, bukan di akhir project.
- Shift-Left (istilah Larry Smith, 2001) berarti memindahkan pengujian ke tahap sedini mungkin: QA ikut membahas kebutuhan dan desain sejak awal.
- Risk-Based Testing memprioritaskan pengujian pada fitur yang paling berisiko, misalnya pembayaran.
- Exploratory Testing adalah pengujian manual tanpa skrip kaku, mengandalkan kreativitas tester untuk menemukan bug yang tidak terduga.
- Teknik desain test klasik dari era Myers (1979) masih wajib dikuasai: Equivalence Partitioning (mengelompokkan input yang perilakunya sama) dan Boundary Value Analysis (menguji tepat di batas nilai, tempat bug paling sering bersembunyi).
TDD & BDD - METODOLOGI QA (LANJUTAN)
- Test-Driven Development (TDD), dipopulerkan Kent Beck (2002), menulis test sebelum kodenya dengan siklus Red, Green, Refactor.
- Red: tulis test untuk fitur yang belum ada, test pasti gagal.
- Green: tulis kode paling sederhana agar test lulus.
- Refactor: rapikan kode, pastikan test tetap lulus.
- Behavior-Driven Development (BDD), diperkenalkan Dan North (2006), menulis skenario dalam bahasa yang dipahami tim bisnis memakai format Given-When-Then (Gherkin), lalu dijalankan otomatis oleh tool seperti Cucumber (2008).
Kode:
Feature: Login
Scenario: Login dengan password salah
Given pengguna berada di halaman login
When pengguna memasukkan password yang salah
Then muncul pesan "Email atau password salah"
6. KEANDALAN SOFTWARE (RELIABILITY)
- Keandalan adalah kemampuan software untuk terus berjalan dengan benar dalam jangka waktu tertentu. Testing sebelum rilis saja tidak cukup, sistem juga harus dipantau setelah rilis.
- Site Reliability Engineering (SRE) dimulai di Google pada tahun 2003 oleh Ben Treynor Sloss dan dipopulerkan lewat buku SRE (2016).
- SLI (Service Level Indicator): angka yang diukur, misalnya persentase request yang berhasil.
- SLO (Service Level Objective): target internal, misalnya 99,9% request berhasil dalam sebulan.
- SLA (Service Level Agreement): janji resmi kepada pelanggan, biasanya disertai kompensasi jika dilanggar.
- Error Budget: sisa toleransi kegagalan dari SLO. Jika habis, tim mengutamakan perbaikan keandalan sebelum menambah fitur.
- MTBF & MTTR: rata-rata waktu antar kegagalan dan rata-rata waktu pemulihan. Sistem andal punya MTBF panjang dan MTTR pendek.
- Chaos Engineering: sengaja membuat gangguan untuk menguji ketahanan sistem. Dipelopori Netflix lewat Chaos Monkey (2010) yang mematikan server secara acak.
- Rilis bertahap: canary release dan feature flag membuat versi baru diberikan ke sebagian kecil pengguna dulu, sehingga kerusakan tidak langsung berdampak ke semua orang.
7. PELACAKAN BUG (BUG TRACKING)
- Pelacakan bug adalah proses mencatat, memprioritaskan, menugaskan, dan memantau setiap bug sampai selesai diperbaiki.
- Tanpa pelacakan yang rapi, bug mudah terlupakan, dikerjakan dua kali, atau dianggap selesai padahal belum.
- Tool yang umum: Bugzilla (1998), Jira (2002), GitHub Issues, GitLab Issues, dan Linear. Untuk error di production, Sentry (2008) mencatat error secara otomatis lengkap dengan lokasinya di kode.
Siklus hidup bug (bug lifecycle):
Kode:
New β Assigned β In Progress β Fixed β Retest β Verified β Closed
β
βββ gagal β Reopened β Assigned
Laporan bug yang baik membuat developer bisa langsung mereproduksi masalahnya:
Kode:
Judul : Tombol "Bayar" tidak merespons di halaman checkout
Lingkungan : Android 14, aplikasi v2.3.1, jaringan 4G
Langkah : 1. Login 2. Tambah produk ke keranjang
3. Buka checkout 4. Tekan "Bayar"
Hasil : Tidak terjadi apa-apa, tidak ada pesan error
Harapan : Muncul halaman pilihan metode pembayaran
Severity : High Priority : P1
Lampiran : screenshot, rekaman layar, log error
| Aspek | Severity | Priority |
|---|---|---|
| Arti | Seberapa parah dampak bug pada sistem | Seberapa cepat bug harus diperbaiki |
| Ditentukan oleh | QA / tester | Product owner / manajer |
| Contoh | Aplikasi crash di menu yang jarang dipakai: severity tinggi, priority bisa rendah | Salah ketik nama perusahaan di halaman utama: severity rendah, priority tinggi |
8. SIAPA ITU QA ENGINEER?
Seorang QA engineer adalah profesional yang memastikan software memenuhi standar kualitas sebelum dan sesudah dirilis, baik melalui pengujian manual maupun otomatis.
QA engineer biasanya melakukan hal-hal berikut:
- Menganalisis kebutuhan dan ikut menentukan kriteria "selesai" sebuah fitur.
- Menyusun test plan dan test case.
- Menjalankan pengujian manual dan exploratory testing.
- Menulis dan merawat automated test, lalu memasangnya di pipeline CI.
- Melaporkan bug dengan jelas dan memverifikasi perbaikannya.
- Memantau kualitas setelah rilis bersama tim developer dan SRE.
Peran yang berkaitan dengan QA:
- Manual QA / Tester β fokus pada test case, eksplorasi, dan pengalaman pengguna.
- QA Automation Engineer / SDET β menulis kode pengujian otomatis dan framework test.
- Performance & Security Tester β menguji kecepatan, beban, dan celah keamanan.
- SRE β menjaga keandalan sistem di production.
9. BAGAIMANA BUG DITEMUKAN HINGGA DIPERBAIKI?
Contoh: pengguna melaporkan total belanja salah saat memakai kode promo.
- Sentry mencatat error, atau QA menemukan bug saat regression test, lalu membuat laporan di Jira lengkap dengan langkah reproduksi.
- Tim menentukan severity dan priority, lalu bug ditugaskan ke developer.
- Developer mereproduksi bug dan menulis test yang gagal karena bug tersebut.
- Developer memperbaiki kode sampai test lulus, lalu membuka Pull Request.
- Pipeline CI menjalankan seluruh test, dan rekan setim melakukan code review.
- Setelah merge, QA memverifikasi di staging dan status bug diubah menjadi Closed. Test baru tadi menjaga agar bug yang sama tidak muncul lagi.
10. PERJALANAN TESTING & QA (1947βSEKARANG)
Banyak konsep pengujian lama masih menjadi dasar praktik modern:
- 1947β1979: Awal Mula β Tim Harvard Mark II menemukan ngengat di dalam komputer dan mencatatnya sebagai "first actual case of bug being found" (1947). Dijkstra merumuskan batas testing (1970), Richard Lipton mengusulkan mutation testing (1971), dan Myers menerbitkan The Art of Software Testing (1979).
- 1980β1999: Standar & Proses β Boehm meneliti biaya bug (1981), standar dokumentasi test IEEE 829 (1983), V-Model, ISO 9001 (1987), CMM (1991), istilah continuous integration (1991), JUnit (1997), serta Bugzilla dan JMeter (1998).
- 2000β2009: Agile & Otomatisasi β Artikel CI Martin Fowler (2000), Agile Manifesto dan Shift-Left (2001), ISTQB dan Jira (2002), Selenium (2004), BDD (2006), Cucumber dan Sentry (2008), serta Test Pyramid (2009).
- 2010β2016: CI dan Keandalan β Chaos Monkey (2010), Jenkins dan model kualitas ISO/IEC 25010 (2011), standar ISO/IEC/IEEE 29119 (2013), Jest (2014), serta buku SRE dari Google (2016).
- 2017β2020: Testing Modern β Cypress (2017), Testing Trophy dan standar W3C WebDriver (2018), GitHub Actions (2019), serta Playwright (2020).
- 2021βSekarang: Quality Engineering & AI β AI mulai membantu membuat test case dan test otomatis. Insiden CrowdStrike (2024) kembali menunjukkan pentingnya pengujian dan rilis bertahap.
Ringkasnya, tool terus berganti, tetapi prinsipnya bertahan puluhan tahun: uji sedini mungkin, otomatiskan yang berulang, uji di batas nilai, dan catat setiap bug dengan rapi.
QA ENGINEER vs. DEVELOPER
Developer
- Fokus membangun fitur sesuai kebutuhan.
- Menulis unit test dan integration test untuk kodenya sendiri.
- Memperbaiki bug yang dilaporkan.
- Tools: IDE, Git, framework unit test.
QA Engineer
- Fokus memastikan kualitas seluruh produk dari sudut pandang pengguna.
- Merancang skenario pengujian, termasuk kasus yang tidak terpikirkan developer.
- Menulis E2E test, menjalankan exploratory testing, dan mengelola laporan bug.
- Tools: Playwright/Cypress, Postman, Jira, tool performance testing.
Kualitas bukan hanya tanggung jawab QA. Developer dan QA bekerja sama sejak awal, bukan saling lempar di akhir.
MENGAPA TESTING & QA PENTING?
Mencegah Kerugian Besar
Sejarah mencatat bug yang lolos pengujian bisa berakibat sangat mahal:
- Therac-25 (1985β1987): mesin terapi radiasi memberikan dosis berlebih akibat bug race condition, menyebabkan korban jiwa.
- Ariane 5 (1996): roket meledak sekitar 37 detik setelah peluncuran karena konversi angka 64-bit ke 16-bit yang overflow.
- Mars Climate Orbiter (1999): wahana hilang karena satu tim memakai satuan imperial dan tim lain memakai satuan metrik.
- Knight Capital (2012): kesalahan deploy menyebabkan kerugian sekitar USD 440 juta dalam 45 menit.
- CrowdStrike (2024): update bermasalah membuat sekitar 8,5 juta komputer Windows crash dan mengganggu bandara, bank, serta rumah sakit di banyak negara.
Developer Lebih Percaya Diri
Dengan test yang baik, developer berani melakukan perubahan dan refactoring karena kesalahan langsung ketahuan.
Karier yang Dibutuhkan
QA Automation Engineer dan SDET banyak dicari, karena perusahaan ingin rilis cepat tanpa mengorbankan kualitas.
ANALOGI TESTING & QA
Testing dan QA lebih mudah dipahami dengan analogi sebuah pabrik mobil.
1. Unit Test β Uji Setiap Komponen
Rem, lampu, dan mesin diuji satu per satu sebelum dirakit. Komponen yang cacat ketahuan sejak awal, saat paling murah diperbaiki.
2. Integration Test β Uji Hasil Rakitan
Mesin dipasang ke transmisi dan diuji apakah keduanya bekerja sama dengan baik.
3. End-to-End Test β Test Drive
Mobil yang sudah jadi dikendarai di jalan seperti pembeli sungguhan. Paling realistis, tetapi butuh waktu dan biaya paling besar.
4. Quality Assurance β Standar Operasional Pabrik
Prosedur kerja, pelatihan, dan inspeksi rutin yang mencegah cacat terjadi, bukan sekadar menemukannya.
5. Pelacakan Bug β Catatan Cacat & Recall
Setiap cacat dicatat, dilacak penyebabnya, dan diperbaiki agar tidak terulang pada produksi berikutnya.
6. Kesimpulan
Kualitas software yang baik terdiri dari:
- Unit Test: setiap bagian kecil benar
- Integration Test: sambungan antar bagian benar
- E2E Test: alur pengguna benar
- QA: proses yang mencegah bug sejak awal
- Pelacakan Bug: setiap masalah tercatat dan tuntas
7 PRINSIP TESTING (ISTQB)
ISTQB (International Software Testing Qualifications Board, berdiri 2002) merumuskan tujuh prinsip testing yang menjadi acuan sertifikasi tester di seluruh dunia:
- Testing menunjukkan adanya bug, bukan membuktikan software bebas bug.
- Pengujian menyeluruh itu mustahil, sehingga pengujian harus diprioritaskan berdasarkan risiko.
- Uji sedini mungkin, karena bug yang ditemukan lebih awal jauh lebih murah diperbaiki.
- Bug cenderung berkumpul, sebagian kecil modul biasanya menyimpan sebagian besar bug.
- Pesticide paradox, test yang sama terus-menerus lama-lama tidak menemukan bug baru, sehingga harus diperbarui.
- Testing bergantung konteks, aplikasi bank dan game diuji dengan cara berbeda.
- Bebas bug belum tentu berguna, software tanpa bug tetap gagal jika tidak sesuai kebutuhan pengguna.
TOOLS TESTING & QA
Berikut tool yang umum digunakan, dikelompokkan berdasarkan fungsinya:
1. Unit & Integration Test
Jest dan Vitest (JavaScript), PHPUnit (PHP), pytest (Python), JUnit (Java).
2. End-to-End Test
Playwright, Cypress, dan Selenium untuk web. Appium untuk aplikasi mobile.
3. API Testing
Postman (2012), Insomnia, serta pengujian API otomatis di dalam framework test.
4. Performance & Load Testing
Apache JMeter (1998), k6, dan Locust untuk mensimulasikan ribuan pengguna.
5. CI/CD
GitHub Actions, GitLab CI, dan Jenkins untuk menjalankan test otomatis di setiap perubahan.
6. Pelacakan Bug & Manajemen Test
Jira, GitHub Issues, dan Linear untuk bug, serta TestRail atau Qase untuk mengelola test case.
7. Monitoring Production
Sentry untuk pelacakan error, serta Grafana dan Prometheus untuk metrik keandalan.
Kesimpulan Singkat
Urutan belajar yang disarankan:
- Pahami dasar testing, teknik desain test case, dan cara menulis laporan bug
- Kuasai unit testing di bahasa yang kamu pakai
- Lanjutkan ke integration test dan API testing
- Pelajari E2E test dengan Playwright atau Cypress
- Pasang semua test di pipeline CI, lalu pelajari dasar keandalan (SLO dan monitoring)
Terakhir diedit: