Blog

Test Suite vs Test Case: Apa Bedanya?

Ashley Innocent

Ashley Innocent

4 March 2026

Test Suite vs Test Case: Apa Bedanya?

Apidog untuk Perusahaan

Penerapan On-Premises

SSO & RBAC

Sesuai SOC 2

Jelajahi Apidog Enterprise

TL;DR

Sebuah kasus uji (test case) adalah skenario pengujian tunggal yang memeriksa satu perilaku atau persyaratan spesifik, sedangkan rangkaian uji (test suite) adalah kumpulan kasus uji terkait yang dikelompokkan bersama untuk eksekusi terorganisir. Kasus uji mendefinisikan apa yang harus diuji dan bagaimana mengujinya. Rangkaian uji mengorganisir beberapa kasus uji ke dalam kelompok logis untuk alur kerja pengujian yang efisien.

Pendahuluan

Anda sedang membangun API. Anda menulis uji pertama Anda. Lalu uji berikutnya. Segera Anda memiliki 50 uji yang tersebar di berbagai file. Mana yang menguji otentikasi? Mana yang dijalankan sebelum deployment? Bagaimana cara menjalankan uji-uji yang penting saja?

Kebingungan ini terjadi ketika pengembang tidak memahami perbedaan antara kasus uji dan rangkaian uji. Sebuah survei tahun 2023 terhadap 1.200 pengembang menemukan bahwa 67% kesulitan dengan organisasi uji, menyebabkan CI/CD pipeline yang lebih lambat dan debugging yang lebih sulit. Kedua konsep ini membentuk dasar pengujian yang terorganisir, tetapi sering digunakan secara bergantian atau disalahpahami.

Memahami perbedaan ini membantu Anda mengatur uji secara logis, menjalankannya secara efisien, dan memeliharanya seiring pertumbuhan API Anda. Baik Anda menguji dengan Apidog atau alat lain, mengetahui kapan harus membuat kasus uji baru dan kapan harus mengelompokkan kasus ke dalam rangkaian uji membuat alur kerja pengujian Anda lebih cepat dan lebih andal.

Dalam panduan ini, Anda akan mempelajari perbedaan pasti antara kasus uji dan rangkaian uji, melihat contoh pengujian API nyata, dan menemukan cara mengorganisir keduanya untuk efisiensi maksimum. Pada akhirnya, Anda akan tahu persis cara menyusun uji API Anda untuk berbagai ukuran proyek.

Apa Itu Kasus Uji (Test Case)?

Kasus uji adalah skenario pengujian tunggal dan spesifik yang memverifikasi satu perilaku atau persyaratan perangkat lunak Anda. Anggap saja sebagai satu pertanyaan yang Anda ajukan pada kode Anda: "Apakah ini berfungsi dengan benar?"

Setiap kasus uji berisi:

Anatomi Kasus Uji

Berikut adalah contoh kasus uji sederhana untuk sebuah endpoint API:

Test Case ID: TC_AUTH_001
Title: Verifikasi login pengguna dengan kredensial valid
Preconditions: Akun pengguna ada di database
Test Steps:
  1. Kirim permintaan POST ke /api/auth/login
  2. Sertakan email dan kata sandi yang valid di body permintaan
  3. Periksa kode status respons
  4. Verifikasi token JWT dikembalikan
Expected Result:
  - Kode status: 200
  - Respons berisi token JWT yang valid
  - Token kedaluwarsa dalam 24 jam
Actual Result: [Akan diisi saat eksekusi]
Status: [Lulus/Gagal]

Kasus uji bersifat atomik. Mereka menguji satu hal dan hanya satu hal. Jika kasus uji Anda memeriksa login DAN pembaruan profil, pisahkan menjadi dua kasus uji.

Contoh Kasus Uji dalam Kode

Begini tampilan kasus uji yang sama dalam JavaScript menggunakan Jest:

describe('Authentication API', () => {
  test('TC_AUTH_001: should login user with valid credentials', async () => {
    const response = await fetch('https://api.example.com/auth/login', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        email: 'user@example.com',
        password: 'SecurePass123'
      })
    });

    expect(response.status).toBe(200);
    const data = await response.json();
    expect(data.token).toBeDefined();
    expect(data.expiresIn).toBe(86400); // 24 hours in seconds
  });
});

Perhatikan bagaimana kasus uji ini berfokus pada satu skenario: login yang berhasil. Ini tidak menguji login yang gagal, reset kata sandi, atau logout. Itu semua akan menjadi kasus uji terpisah.

Mengapa Kasus Uji Penting

Kasus uji memberi Anda:

Tanpa kasus uji yang jelas, Anda berakhir dengan uji yang ambigu yang memeriksa banyak hal sekaligus. Ketika gagal, Anda membuang waktu mencari tahu bagian mana yang rusak.

Apa Itu Rangkaian Uji (Test Suite)?

Rangkaian uji adalah kumpulan kasus uji yang dikelompokkan bersama untuk eksekusi terorganisir. Jika kasus uji adalah pertanyaan individu, rangkaian uji adalah ujian yang berisi pertanyaan-pertanyaan terkait.

Rangkaian uji mengorganisir kasus uji berdasarkan:

Struktur Rangkaian Uji

Begini cara rangkaian uji mengorganisir kasus uji:

Rangkaian Uji: Modul Otentikasi
├── Kasus Uji 1: Login dengan kredensial valid
├── Kasus Uji 2: Login dengan kata sandi tidak valid
├── Kasus Uji 3: Login dengan email yang tidak ada
├── Kasus Uji 4: Login dengan token kedaluwarsa
├── Kasus Uji 5: Logout berhasil
└── Kasus Uji 6: Refresh token akses

Rangkaian Uji: Modul Profil Pengguna
├── Kasus Uji 1: Mendapatkan profil pengguna
├── Kasus Uji 2: Memperbarui informasi profil
├── Kasus Uji 3: Mengunggah gambar profil
└── Kasus Uji 4: Menghapus akun pengguna

Setiap rangkaian uji berisi beberapa kasus uji terkait. Anda dapat menjalankan seluruh rangkaian sekaligus atau memilih kasus uji individu untuk dijalankan.

Contoh Rangkaian Uji dalam Kode

Begini tampilan rangkaian uji dalam JavaScript:

// Rangkaian uji otentikasi
describe('Authentication API Test Suite', () => {

  test('TC_AUTH_001: Login with valid credentials', async () => {
    // Implementasi uji
  });

  test('TC_AUTH_002: Login with invalid password', async () => {
    // Implementasi uji
  });

  test('TC_AUTH_003: Login with non-existent email', async () => {
    // Implementasi uji
  });

  test('TC_AUTH_004: Logout successfully', async () => {
    // Implementasi uji
  });
});

// Rangkaian uji profil pengguna
describe('User Profile API Test Suite', () => {

  test('TC_PROFILE_001: Get user profile', async () => {
    // Implementasi uji
  });

  test('TC_PROFILE_002: Update profile information', async () => {
    // Implementasi uji
  });
});

Blok describe() membuat rangkaian uji. Setiap test() di dalamnya adalah kasus uji. Anda dapat menjalankan semua uji otentikasi dengan satu perintah atau menjalankan seluruh file uji.

Rangkaian Uji Bersarang

Rangkaian uji dapat berisi rangkaian uji lain untuk proyek yang kompleks:

describe('API Test Suite', () => {

  describe('Authentication', () => {
    describe('Login', () => {
      test('with valid credentials', () => {});
      test('with invalid password', () => {});
    });

    describe('Registration', () => {
      test('with valid data', () => {});
      test('with duplicate email', () => {});
    });
  });

  describe('User Management', () => {
    test('get user list', () => {});
    test('update user role', () => {});
  });
});

Ini menciptakan hirarki: Rangkaian Utama → Sub-rangkaian → Kasus Uji. Struktur ini mencerminkan arsitektur API Anda.

Perbedaan Utama Antara Rangkaian Uji dan Kasus Uji

Berikut adalah perbandingan yang jelas:

Aspek Kasus Uji Rangkaian Uji
Definisi Skenario uji tunggal Kumpulan kasus uji
Cakupan Menguji satu perilaku spesifik Menguji beberapa perilaku terkait
Granularitas Atomik (tidak dapat dipecah) Komposit (berisi beberapa item)
Eksekusi Menjalankan satu uji Menjalankan beberapa uji
Tujuan Memverifikasi satu persyaratan Mengorganisir dan mengelompokkan uji
Hasil Lulus atau Gagal Ringkasan dari semua hasil uji
Contoh "Login dengan kredensial valid" "Uji Modul Otentikasi"
Kode Satu fungsi test() atau it() Satu blok describe() atau suite()
Reusabilitas Dapat ditambahkan ke beberapa rangkaian Dapat berisi kasus uji bersama
Pemeliharaan Memperbarui satu uji Memperbarui beberapa uji sekaligus

Analogi Kontainer

Pikirkan seperti ini:

Anda bisa memiliki file tanpa folder (kasus uji tanpa rangkaian), tetapi folder membantu mengorganisir file (rangkaian membantu mengorganisir kasus uji). Anda juga bisa memiliki folder di dalam folder (rangkaian uji bersarang).

Perbedaan Eksekusi

Ketika Anda menjalankan kasus uji:

# Jalankan satu uji spesifik
npm test -- --testNamePattern="Login with valid credentials"

Ketika Anda menjalankan rangkaian uji:

# Jalankan semua uji dalam rangkaian Otentikasi
npm test -- --testPathPattern="authentication"

Rangkaian uji memungkinkan Anda menjalankan kelompok uji terkait tanpa menjalankan seluruh koleksi uji Anda.

Bagaimana Rangkaian Uji dan Kasus Uji Bekerja Bersama

Kasus uji dan rangkaian uji bukanlah konsep yang bersaing. Mereka bekerja sama untuk menciptakan kode uji yang terorganisir dan mudah dipelihara.

Hubungan

Proyek
└── Rangkaian Uji (Folder)
    └── Kasus Uji (File)
        └── Langkah-langkah Uji (Kode)

Setiap kasus uji termasuk setidaknya dalam satu rangkaian uji. Sebuah kasus uji dapat termasuk dalam beberapa rangkaian:

// smoke-tests.suite.js
describe('Smoke Tests', () => {
  test('TC_SMOKE_001: API health check', () => {});
  test('TC_SMOKE_002: Database connection', () => {});
  test('TC_AUTH_001: Login with valid credentials', () => {}); // Dibagikan
});

// authentication.suite.js
describe('Authentication Tests', () => {
  test('TC_AUTH_001: Login with valid credentials', async () => {}); // Dibagikan
  test('TC_AUTH_002: Login with invalid password', async () => {});
  test('TC_AUTH_003: Password reset flow', async () => {});
});

Kasus uji TC_AUTH_001 muncul di rangkaian uji smoke dan rangkaian uji otentikasi. Reusabilitas ini memungkinkan Anda menjalankan uji yang sama dalam konteks yang berbeda tanpa duplikasi.

Integrasi Alur Kerja

Begini cara kerjanya dalam alur kerja pengembangan yang khas:

  1. Tulis kasus uji untuk fitur baru
  2. Kelompokkan kasus uji ke dalam rangkaian uji logis
  3. Jalankan rangkaian spesifik selama pengembangan (umpan balik cepat)
  4. Jalankan semua rangkaian sebelum deployment (pemeriksaan komprehensif)
  5. Analisis hasil rangkaian untuk mengidentifikasi area masalah

Strategi Eksekusi

Situasi yang berbeda memerlukan strategi eksekusi yang berbeda:

# Selama pengembangan: Jalankan satu kasus uji
npm test -- --testNamePattern="TC_AUTH_001"

# Sebelum melakukan commit: Jalankan rangkaian uji terkait
npm test -- authentication.test.js

# Di CI/CD: Jalankan semua rangkaian uji kritis
npm test -- --testPathPattern="(smoke|critical)"

# Sebelum rilis: Jalankan semuanya
npm test

Pendekatan berlapis ini menghemat waktu. Jalankan 5 uji smoke dalam 10 detik, alih-alih 200 uji dalam 5 menit selama pengembangan. Simpan rangkaian lengkap untuk CI/CD.

Rangkaian Uji vs Kasus Uji dalam Pengujian API

Pengujian API memiliki karakteristik unik yang memengaruhi cara Anda mengorganisir kasus uji dan rangkaian uji.

Struktur Kasus Uji API

Kasus uji API biasanya memverifikasi:

Berikut adalah kasus uji API lengkap:

test('TC_USER_001: Create new user via POST /api/users', async () => {
  // Arrange
  const newUser = {
    name: 'John Doe',
    email: 'john@example.com',
    role: 'user'
  };

  // Act
  const response = await fetch('https://api.example.com/users', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer test-token'
    },
    body: JSON.stringify(newUser)
  });

  const data = await response.json();

  // Assert
  expect(response.status).toBe(201);
  expect(data.id).toBeDefined();
  expect(data.name).toBe(newUser.name);
  expect(data.email).toBe(newUser.email);
  expect(data.createdAt).toBeDefined();
});

Kasus uji ini memeriksa satu operasi API: membuat pengguna. Ini tidak menguji pembaruan, penghapusan, atau daftar pengguna.

Organisasi Rangkaian Uji API

Untuk API, atur rangkaian uji berdasarkan:

1. Berdasarkan Endpoint

Rangkaian Uji: /api/users
├── GET /api/users (daftar pengguna)
├── POST /api/users (buat pengguna)
├── GET /api/users/:id (dapatkan pengguna)
├── PUT /api/users/:id (perbarui pengguna)
└── DELETE /api/users/:id (hapus pengguna)

2. Berdasarkan FiturRangkaian Uji: Manajemen Pengguna ├── Registrasi pengguna ├── Otentikasi pengguna ├── Manajemen profil └── Penghapusan akun

3. Berdasarkan Tipe Uji

Rangkaian Uji: Smoke Tests
├── Pemeriksaan kesehatan API
├── Konektivitas database
└── Endpoint penting merespons

Rangkaian Uji: Integration Tests
├── Alur registrasi pengguna
├── Alur pemrosesan pesanan
└── Alur pemrosesan pembayaran

Manajemen Rangkaian Uji Apidog

Apidog membuat pengorganisasian rangkaian uji API menjadi visual dan intuitif. Alih-alih menulis kode, Anda membangun kasus uji dalam GUI dan mengelompokkannya ke dalam rangkaian uji dengan drag-and-drop. Ini memangkas waktu pembuatan uji sebesar 60% dibandingkan dengan pendekatan berbasis kode.

Begini cara Apidog menangani organisasi uji:

Kasus Uji di Apidog:

Anda dapat membuat kasus uji dengan beberapa cara:

Di tab Test Cases pada halaman detail endpoint, klik + Add Case untuk membuat secara manual.

Saat menambahkan kasus uji, Anda dapat memilih

Sebuah kasus uji berisi informasi berikut:

Rangkaian Uji di Apidog:

image.png
image.png

Manfaat:

Anda dapat mengekspor rangkaian uji Apidog ke kode jika diperlukan, memberi Anda fleksibilitas antara pengujian berbasis GUI dan berbasis kode.

Kapan Menggunakan Kasus Uji vs Rangkaian Uji

Mengetahui kapan harus membuat kasus uji baru dan kapan harus mengelompokkan kasus ke dalam rangkaian uji sangat penting untuk uji yang mudah dipelihara.

Buat Kasus Uji Baru Ketika:

  1. Menguji persyaratan baru: Setiap persyaratan harus memiliki setidaknya satu kasus uji
  2. Menguji skenario yang berbeda: Login valid vs login tidak valid = dua kasus uji
  3. Menguji kasus batas (edge cases): Input kosong, input maksimum, karakter khusus
  4. Menguji kondisi kesalahan: Kesalahan 400, kesalahan 500, skenario timeout
  5. Menguji data yang berbeda: Peran pengguna yang berbeda, izin yang berbeda

Buat Rangkaian Uji Baru Ketika:

  1. Anda memiliki 5+ kasus uji terkait: Kelompokkan untuk organisasi
  2. Menguji fitur lengkap: Semua uji otentikasi bersama-sama
  3. Membuat kategori uji: Uji smoke, uji regresi, uji performa
  4. Mengorganisir berdasarkan prioritas: Uji kritis, prioritas tinggi, prioritas rendah
  5. Memisahkan berdasarkan lingkungan: Uji staging, uji produksi

Anti-Pola yang Harus Dihindari

Jangan lakukan ini:

// BURUK: Satu kasus uji raksasa yang menguji segalanya
test('Test entire user flow', () => {
  // Mendaftarkan pengguna
  // Login pengguna
  // Memperbarui profil
  // Membuat postingan
  // Menghapus postingan
  // Logout
  // Menghapus akun
});

Lakukan ini sebagai gantinya:

// BAIK: Pisahkan kasus uji dalam rangkaian yang terorganisir
describe('User Management Suite', () => {
  test('TC_001: Register new user', () => {});
  test('TC_002: Login with credentials', () => {});
  test('TC_003: Update user profile', () => {});
});

describe('Content Management Suite', () => {
  test('TC_004: Create new post', () => {});
  test('TC_005: Delete post', () => {});
});

Jangan lakukan ini:

// BURUK: Terlalu banyak rangkaian bersarang
describe('API', () => {
  describe('V1', () => {
    describe('Users', () => {
      describe('Authentication', () => {
        describe('Login', () => {
          describe('Valid Credentials', () => {
            test('with email', () => {});
          });
        });
      });
    });
  });
});

Lakukan ini sebagai gantinya:

// BAIK: Bersarang yang wajar (maksimal 2-3 tingkat)
describe('API V1: User Authentication', () => {
  describe('Login', () => {
    test('with valid email and password', () => {});
    test('with invalid password', () => {});
  });

  describe('Registration', () => {
    test('with valid data', () => {});
  });
});

Praktik Terbaik untuk Mengorganisir Kasus Uji dan Rangkaian Uji

Ikuti strategi yang terbukti ini untuk menjaga uji Anda tetap terorganisir dan mudah dipelihara.

1. Gunakan Konvensi Penamaan yang Jelas

Kasus Uji:

// Baik: Deskriptif dan spesifik
test('should return 200 when user logs in with valid credentials', () => {});
test('should return 401 when password is incorrect', () => {});
test('should return 404 when user does not exist', () => {});

// Buruk: Tidak jelas dan samar
test('login test', () => {});
test('test 1', () => {});
test('check user', () => {});

Rangkaian Uji:

// Baik: Cakupan dan tujuan yang jelas
describe('Authentication API - Login Endpoint', () => {});
describe('User Profile Management', () => {});
describe('Payment Processing Integration Tests', () => {});

// Buruk: Terlalu umum
describe('Tests', () => {});
describe('API', () => {});
describe('Stuff', () => {});

2. Jaga Kasus Uji Tetap Independen

Setiap kasus uji harus berjalan secara independen tanpa bergantung pada uji lain:

// BURUK: Uji bergantung satu sama lain
let userId;

test('create user', async () => {
  const response = await createUser();
  userId = response.id; // Menyimpan status
});

test('update user', async () => {
  await updateUser(userId); // Bergantung pada uji sebelumnya
});

// BAIK: Setiap uji independen
test('create user', async () => {
  const response = await createUser();
  expect(response.status).toBe(201);
  await cleanup(response.id); // Membersihkan setelah uji
});

test('update user', async () => {
  const user = await createUser(); // Buat data uji sendiri
  const response = await updateUser(user.id);
  expect(response.status).toBe(200);
  await cleanup(user.id);
});

3. Atur Rangkaian Berdasarkan Fitur atau Modul

Cerminkan struktur API Anda dalam organisasi uji Anda:

src/
├── auth/
│   ├── login.js
│   └── register.js
├── users/
│   ├── profile.js
│   └── settings.js
└── posts/
    ├── create.js
    └── delete.js

tests/
├── auth/
│   ├── login.test.js (Rangkaian Uji)
│   └── register.test.js (Rangkaian Uji)
├── users/
│   ├── profile.test.js (Rangkaian Uji)
│   └── settings.test.js (Rangkaian Uji)
└── posts/
    ├── create.test.js (Rangkaian Uji)
    └── delete.test.js (Rangkaian Uji)

4. Gunakan Kait Setup dan Teardown

Kurangi duplikasi dengan kait before/after:

describe('User API Test Suite', () => {
  let authToken;
  let testUser;

  // Berjalan sekali sebelum semua uji dalam rangkaian ini
  beforeAll(async () => {
    authToken = await getAuthToken();
  });

  // Berjalan sebelum setiap kasus uji
  beforeEach(async () => {
    testUser = await createTestUser();
  });

  // Berjalan setelah setiap kasus uji
  afterEach(async () => {
    await deleteTestUser(testUser.id);
  });

  // Berjalan sekali setelah semua uji dalam rangkaian ini
  afterAll(async () => {
    await revokeAuthToken(authToken);
  });

  test('TC_001: Get user profile', async () => {
    // testUser dan authToken tersedia
  });

  test('TC_002: Update user profile', async () => {
    // testUser dan authToken tersedia
  });
});

5. Beri Tag Uji untuk Eksekusi Fleksibel

Gunakan tag atau kategori untuk menjalankan kelompok uji spesifik:

describe('Authentication Suite', () => {
  test('[smoke] API health check', () => {});
  test('[critical] Login with valid credentials', () => {});
  test('[regression] Login with expired token', () => {});
  test('[edge-case] Login with special characters in password', () => {});
});

// Jalankan hanya uji smoke
// npm test -- --testNamePattern="smoke"

// Jalankan uji kritis
// npm test -- --testNamePattern="critical"

6. Pertahankan Hirarki Rangkaian Uji

Buat hirarki yang jelas untuk proyek besar:

Level 1: Tipe Uji (Smoke, Integrasi, E2E)
  └── Level 2: Modul Fitur (Otentikasi, Pengguna, Pesanan)
      └── Level 3: Fungsionalitas Spesifik (Login, Daftar)
          └── Level 4: Kasus Uji (Valid, Tidak Valid, Kasus Batas)

Contoh:

describe('[Integration] User Management', () => {
  describe('Authentication', () => {
    describe('Login', () => {
      test('with valid credentials', () => {});
      test('with invalid password', () => {});
      test('with non-existent email', () => {});
    });
  });
});

Kesalahan Umum yang Harus Dihindari

1. Membuat Kasus Uji yang Terlalu Luas

Masalah:

test('test user functionality', () => {
  // Menguji registrasi, login, pembaruan profil, dan penghapusan
  // Jika ini gagal, bagian mana yang rusak?
});

Solusi:

test('should register new user', () => {});
test('should login registered user', () => {});
test('should update user profile', () => {});
test('should delete user account', () => {});

2. Tidak Mengelompokkan Kasus Uji Terkait

Masalah:

test('login test 1', () => {});
test('profile test 1', () => {});
test('login test 2', () => {});
test('order test 1', () => {});
test('profile test 2', () => {});

Solusi:

describe('Login Tests', () => {
  test('test 1', () => {});
  test('test 2', () => {});
});

describe('Profile Tests', () => {
  test('test 1', () => {});
  test('test 2', () => {});
});

3. Membuat Terlalu Banyak Rangkaian Bersarang

Masalah:

describe('API', () => {
  describe('Version 1', () => {
    describe('Users', () => {
      describe('Profile', () => {
        describe('Update', () => {
          test('with valid data', () => {});
        });
      });
    });
  });
});

Solusi:

describe('API V1: User Profile', () => {
  test('should update profile with valid data', () => {});
});

4. Mengabaikan Urutan Eksekusi Uji

Masalah:

describe('User Flow', () => {
  test('delete user', () => {}); // Berjalan pertama
  test('create user', () => {}); // Berjalan kedua
  test('update user', () => {}); // Berjalan ketiga
});

Solusi:

describe('User Flow', () => {
  test('1. create user', () => {});
  test('2. update user', () => {});
  test('3. delete user', () => {});
});

// Atau gunakan beforeEach untuk memastikan setup yang benar

5. Tidak Menggunakan Nama yang Deskriptif

Masalah:

describe('Suite 1', () => {
  test('test 1', () => {});
  test('test 2', () => {});
});

Solusi:

describe('Authentication API Tests', () => {
  test('should return JWT token on successful login', () => {});
  test('should return 401 on invalid credentials', () => {});
});

Contoh Dunia Nyata

Contoh 1: Organisasi Uji API E-commerce

// Smoke Test Suite - Berjalan pada setiap commit
describe('[Smoke] Critical API Endpoints', () => {
  test('TC_SMOKE_001: API health check returns 200', async () => {
    const response = await fetch('https://api.shop.com/health');
    expect(response.status).toBe(200);
  });

  test('TC_SMOKE_002: Database connection is active', async () => {
    const response = await fetch('https://api.shop.com/db-status');
    expect(response.json()).toHaveProperty('connected', true);
  });
});

// Rangkaian Uji Otentikasi
describe('[Integration] Authentication Module', () => {
  describe('User Registration', () => {
    test('TC_AUTH_001: Register with valid email and password', async () => {
      // Implementasi uji
    });

    test('TC_AUTH_002: Reject registration with duplicate email', async () => {
      // Implementasi uji
    });

    test('TC_AUTH_003: Reject weak passwords', async () => {
      // Implementasi uji
    });
  });

  describe('User Login', () => {
    test('TC_AUTH_004: Login with valid credentials', async () => {
      // Implementasi uji
    });

    test('TC_AUTH_005: Reject invalid password', async () => {
      // Implementasi uji
    });
  });
});

// Rangkaian Uji Manajemen Produk
describe('[Integration] Product Management', () => {
  test('TC_PROD_001: Get product list', async () => {
    // Implementasi uji
  });

  test('TC_PROD_002: Get product by ID', async () => {
    // Implementasi uji
  });

  test('TC_PROD_003: Search products by name', async () => {
    // Implementasi uji
  });

  test('TC_PROD_004: Filter products by category', async () => {
    // Implementasi uji
  });
});

// Rangkaian Uji Pemrosesan Pesanan
describe('[Integration] Order Processing', () => {
  test('TC_ORDER_001: Create order with valid items', async () => {
    // Implementasi uji
  });

  test('TC_ORDER_002: Calculate correct order total', async () => {
    // Implementasi uji
  });

  test('TC_ORDER_003: Apply discount code', async () => {
    // Implementasi uji
  });

  test('TC_ORDER_004: Process payment', async () => {
    // Implementasi uji
  });
});

Contoh 2: Struktur Rangkaian Uji Apidog

Di Apidog, Anda mengorganisir uji secara visual:

📁 Uji API E-commerce
  📁 Smoke Tests (Rangkaian)
    ✓ Pemeriksaan Kesehatan API (Kasus Uji)
    ✓ Status Database (Kasus Uji)

  📁 Otentikasi (Rangkaian)
    📁 Registrasi (Sub-rangkaian)
      ✓ Registrasi Valid (Kasus Uji)
      ✓ Email Duplikat (Kasus Uji)
      ✓ Kata Sandi Lemah (Kasus Uji)
    📁 Login (Sub-rangkaian)
      ✓ Login Valid (Kasus Uji)
      ✓ Kata Sandi Tidak Valid (Kasus Uji)

  📁 Produk (Rangkaian)
    ✓ Daftar Produk (Kasus Uji)
    ✓ Dapatkan Detail Produk (Kasus Uji)
    ✓ Cari Produk (Kasus Uji)

  📁 Pesanan (Rangkaian)
    ✓ Buat Pesanan (Kasus Uji)
    ✓ Hitung Total (Kasus Uji)
    ✓ Terapkan Diskon (Kasus Uji)

Setiap kasus uji di Apidog meliputi:

Anda dapat menjalankan kasus uji individu, seluruh rangkaian, atau membuat eksekusi uji khusus yang menggabungkan kasus dari beberapa rangkaian.

Kesimpulan

Kasus uji dan rangkaian uji melayani tujuan yang berbeda tetapi saling melengkapi dalam pengujian API. Kasus uji memverifikasi perilaku individu dengan input spesifik dan output yang diharapkan. Rangkaian uji mengorganisir kasus uji terkait ke dalam kelompok logis untuk eksekusi dan pemeliharaan yang efisien.

Poin-poin penting:

Mulailah dengan menulis kasus uji yang terfokus untuk setiap endpoint API. Seiring pertumbuhan koleksi uji Anda, kelompokkan kasus terkait ke dalam rangkaian. Gunakan tag dan konvensi penamaan untuk membuat uji mudah ditemukan dan dijalankan. Baik Anda menulis uji dalam kode atau menggunakan alat seperti Apidog, prinsip-prinsipnya tetap sama: kasus uji atomik, rangkaian uji logis, organisasi yang jelas.

Siap mengorganisir uji API Anda? Coba manajemen rangkaian uji visual Apidog - buat, atur, dan jalankan kasus uji tanpa menulis kode. Kurangi waktu pengaturan uji Anda sebesar 60% dan jalankan rangkaian uji pertama Anda dalam waktu kurang dari 5 menit.

tombol

FAQ

Apa perbedaan utama antara kasus uji dan rangkaian uji?

Kasus uji adalah uji tunggal yang memverifikasi satu perilaku atau persyaratan spesifik. Rangkaian uji adalah kumpulan dari beberapa kasus uji terkait yang dikelompokkan bersama untuk eksekusi terorganisir. Anggap kasus uji sebagai pertanyaan individu dan rangkaian uji sebagai ujian yang berisi pertanyaan-pertanyaan tersebut.

Bisakah sebuah kasus uji termasuk dalam beberapa rangkaian uji?

Ya. Sebuah kasus uji tunggal dapat disertakan dalam beberapa rangkaian uji. Misalnya, kasus uji login kritis mungkin muncul di rangkaian "Smoke Tests" dan rangkaian "Authentication Tests" Anda. Reusabilitas ini membantu Anda menjalankan kombinasi uji yang berbeda untuk tujuan yang berbeda.

Berapa banyak kasus uji yang seharusnya ada dalam sebuah rangkaian uji?

Tidak ada aturan yang ketat, tetapi 5-15 kasus uji per rangkaian adalah rentang yang baik. Jika Anda memiliki lebih dari 20 kasus uji dalam satu rangkaian, pertimbangkan untuk membaginya menjadi rangkaian yang lebih kecil dan lebih terfokus. Jika Anda memiliki kurang dari 5, Anda mungkin tidak membutuhkan rangkaian sama sekali.

Haruskah saya menulis kasus uji atau rangkaian uji terlebih dahulu?

Tulis kasus uji terlebih dahulu. Mulailah dengan membuat uji individu untuk perilaku spesifik. Setelah Anda memiliki beberapa kasus uji terkait, kelompokkan mereka ke dalam rangkaian uji. Pendekatan bottom-up ini memastikan kasus uji Anda terfokus dan rangkaian Anda terorganisir secara logis.

Apa perbedaan antara rangkaian uji dan skenario uji?

Skenario uji adalah deskripsi tingkat tinggi tentang apa yang akan diuji (misalnya, "Alur login pengguna"). Rangkaian uji adalah kumpulan kasus uji yang dapat dieksekusi. Sebuah skenario uji mungkin menjadi rangkaian uji yang berisi beberapa kasus uji yang memverifikasi aspek-aspek berbeda dari skenario tersebut.

Bagaimana cara mengorganisir rangkaian uji untuk API besar?

Gunakan struktur hirarkis: atur berdasarkan fitur atau modul pada tingkat teratas, kemudian berdasarkan fungsionalitas, kemudian berdasarkan tipe uji. Contoh: "Manajemen Pengguna" (modul) → "Otentikasi" (fungsionalitas) → "Uji Login" (rangkaian uji) → kasus uji individu. Pertahankan kedalaman bersarang maksimal 2-3 tingkat.

Bisakah rangkaian uji berisi rangkaian uji lain?

Ya. Rangkaian uji dapat bersarang untuk menciptakan hirarki. Misalnya, rangkaian "Uji API" mungkin berisi sub-rangkaian "Uji Otentikasi" dan "Uji Manajemen Pengguna". Namun, hindari bersarang yang berlebihan (lebih dari 3 tingkat) karena akan membuat uji lebih sulit dinavigasi dan dipelihara.

Alat apa saja yang membantu mengelola kasus uji dan rangkaian uji?

Alat populer meliputi Jest dan Mocha untuk JavaScript, Pytest untuk Python, JUnit untuk Java, dan Postman untuk pengujian API. Apidog menawarkan manajemen rangkaian uji visual tanpa pengkodean, membuatnya mudah untuk mengorganisir dan mengeksekusi kasus uji API melalui antarmuka GUI.

Mengembangkan API dengan Apidog

Apidog adalah alat pengembangan API yang membantu Anda mengembangkan API dengan lebih mudah dan efisien.

Daftar gratisUnduh
Test Suite vs Test Case: Apa Bedanya?