Unit Test #

Unit test adalah lapisan pengujian paling dasar, paling cepat, dan paling banyak jumlahnya di dalam piramida pengujian kita. Sesuai dengan namanya, unit test dirancang untuk menguji satu “unit” terkecil dari kode kita — seperti sebuah fungsi mandiri, metode di dalam kelas, Repositori data, atau pengelola state (state notifier) — secara terisolasi. Isolasi penuh ini berarti unit test berjalan langsung di atas Dart VM tanpa memuat mesin grafis Flutter, tanpa menyentuh sistem jaringan internet asli, dan tanpa membaca berkas fisik database di disk perangkat.

Karena berjalan dalam lingkungan terisolasi yang murni berbasis memori, unit test dapat dieksekusi dalam hitungan milidetik. Kecepatan ini memberikan umpan balik (feedback loop) yang instan bagi kita saat melakukan modifikasi kode. Ketika terjadi kegagalan pada unit test, kita dapat langsung mengidentifikasi baris logika mana yang bermasalah secara presisi. Di dalam panduan ini, kita akan membahas tuntas teknik penulisan unit test di Flutter, mulai dari pola AAA (Arrange-Act-Assert), teknik mocking tingkat lanjut menggunakan Mocktail, pengujian fungsi murni, hingga pengujian state management Riverpod dan BLoC.

Setup & Dependensi #

Untuk mulai menulis unit test di Flutter, kita tidak perlu menambahkan banyak pustaka eksternal karena dependensi pengujian bawaan Dart dan Flutter sudah terkonfigurasi secara otomatis saat kita membuat proyek Flutter baru. Namun, untuk mempermudah proses pembuatan objek tiruan (mocking) secara deklaratif tanpa menulis kode tiruan manual atau memicu generator kode, kita sangat disarankan untuk menggunakan paket Mocktail.

Tambahkan dependensi berikut pada bagian dev_dependencies di berkas pubspec.yaml kita:

dev_dependencies:
  flutter_test:
    sdk: flutter
  mocktail: ^1.0.4
  bloc_test: ^9.1.7 # Wajib jika kita menggunakan Cubit/BLoC untuk state management

Setelah menambahkan paket tersebut, jalankan perintah flutter pub get di terminal proyek untuk mengunduh pustaka.

Anatomi Unit Test & Pola AAA (Arrange-Act-Assert) #

Menulis pengujian yang terstruktur dengan baik akan mempermudah kita dalam membaca ulang kode tes di kemudian hari. Struktur penulisan unit test yang ideal mengikuti pola AAA (Arrange, Act, Assert):

Arrange (Persiapan): Tahap untuk menyiapkan seluruh kondisi awal pengujian. Skenario ini meliputi pembuatan instance kelas yang akan diuji, instansiasi objek mock dependency, serta pendefinisian perilaku tiruan (stubbing) menggunakan metode when().
Act (Aksi): Tahap untuk mengeksekusi metode atau fungsi sesungguhnya yang sedang diuji (System Under Test / SUT).
Assert (Verifikasi): Tahap untuk mencocokkan hasil eksekusi (pada tahap Act) dengan nilai ekspektasi kita menggunakan fungsi expect(), serta memastikan dependensi dipanggil dengan benar menggunakan metode verify().

Berikut adalah struktur anatomi unit test lengkap pada kelas Repositori:

// test/features/products/data/repositories/product_repository_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:flutter_app/features/products/data/repositories/product_repository_impl.dart';
import 'package:flutter_app/features/products/data/models/product_model.dart';

// 1. Definisikan kelas tiruan (Mock) menggunakan Mocktail
class MockProductRemoteDataSource extends Mock implements ProductRemoteDataSource {}
class MockProductLocalDataSource extends Mock implements ProductLocalDataSource {}

void main() {
  // group: Mengelompokkan rangkaian tes yang memiliki kesamaan konteks
  group('Pengujian ProductRepositoryImpl', () {
    late ProductRepositoryImpl repository;
    late MockProductRemoteDataSource mockRemote;
    late MockProductLocalDataSource mockLocal;

    // setUp: Dijalankan secara otomatis sebelum SETIAP tes individu berjalan
    setUp(() {
      mockRemote = MockProductRemoteDataSource();
      mockLocal = MockProductLocalDataSource();
      
      // Inisialisasi SUT dengan menyuntikkan dependensi mock
      repository = ProductRepositoryImpl(
        remoteDataSource: mockRemote,
        localDataSource: mockLocal,
      );
    });

    // tearDown: Dijalankan setelah SETIAP tes selesai (sangat baik untuk membersihkan memori)
    tearDown(() {
      // Skenario pembersihan resource jika diperlukan
    });

    test('Harus mengembalikan daftar produk dari cache lokal jika data tersedia', () async {
      // ==========================================
      // ARRANGE (Persiapan Kondisi)
      // ==========================================
      final listCacheDummy = [
        ProductModel(id: '1', name: 'Laptop Pro', price: 15000000.0),
      ];
      
      // Stubbing: Tentukan perilaku mock local data source
      when(() => mockLocal.getCachedProducts()).thenAnswer((_) async => listCacheDummy);

      // ==========================================
      // ACT (Eksekusi Aksi)
      // ==========================================
      final result = await repository.getProductsList();

      // ==========================================
      // ASSERT (Verifikasi Hasil)
      // ==========================================
      expect(result, equals(listCacheDummy));
      
      // Verifikasi bahwa cache lokal benar-benar diakses sekali
      verify(() => mockLocal.getCachedProducts()).called(1);
      
      // Verifikasi bahwa jaringan internet (remote) sama sekali tidak diakses
      verifyNever(() => mockRemote.fetchProducts());
    });
  });
}

Arsitektur Alur Pengujian Unit (Data Flow) #

Agar kita memahami alur pemrosesan data antara aplikasi pengujian unit, System Under Test (SUT), dan ketergantungan tiruan (Mock Dependency), perhatikan diagram alur di bawah ini. Diagram ini menggambarkan bagaimana pola AAA (Arrange-Act-Assert) berinteraksi di memori RAM selama pengujian berlangsung.

graph TD
    Test["Aplikasi Unit Test"] -->|1. Setup Mock & Container| Env["Environment Test (ProviderContainer / Cubit)"]
    Test -->|2. Stubbing (when/thenAnswer)| Mock["Mock Dependency (Mocktail)"]
    Env -->|3. Picu Logika Aksi (Act)| System["System Under Test (SUT)"]
    System -->|4. Panggil Dependency| Mock
    Mock -->|5. Kembalikan Nilai Simulasi| System
    System -->|6. Emisi State Baru / Return Value| Env
    Env -->|7. Verifikasi & Pencocokan (Assert/Expect)| Test

Melalui alur kerja di atas, pengujian unit kita terbebas dari interaksi disk I/O maupun jaringan internet asli. Keberadaan Mock memastikan kita hanya menguji logika internal SUT tanpa terpengaruh oleh kegagalan di lapisan luar.

Teknik Mocking & Stubbing dengan Mocktail #

Pustaka Mocktail bekerja menggunakan fitur refleksi runtime Dart, sehingga kita tidak perlu menjalankan perintah build_runner yang memakan waktu lama untuk membuat kelas-kelas tiruan.

Berikut adalah panduan teknik stubbing dan verifikasi tingkat lanjut menggunakan Mocktail:

1. Pendaftaran Fallback Value #

Jika metode dari kelas tiruan kita menerima argumen berupa objek kustom (bukan tipe data primitif seperti String atau int), kita wajib mendaftarkan nilai fallback (fallback value) pada metode setUpAll(). Hal ini diperlukan agar Mocktail tahu nilai default apa yang harus diberikan jika ada pencocokan argumen acak menggunakan matcher any().

void main() {
  setUpAll(() {
    // Daftarkan instansiasi objek kosong sebagai fallback
    registerFallbackValue(ProductModel(id: '', name: '', price: 0.0));
  });
  
  // Rangkaian group test...
}

2. Berbagai Metode Stubbing (when) #

Kita dapat menentukan nilai kembalian tiruan berdasarkan skenario pengujian kita:

final mockRepository = MockProductRepository();

// A. thenReturn: Mengembalikan nilai secara sinkron (non-Future)
when(() => mockRepository.dbVersion).thenReturn(1);

// B. thenAnswer: Mengembalikan nilai secara asinkron (Future / Stream)
when(() => mockRepository.getProductsList())
    .thenAnswer((_) async => <ProductModel>[]);

// C. thenThrow: Mensimulasikan terjadinya kesalahan / Exception
when(() => mockRepository.deleteProduct(any()))
    .thenThrow(Exception('Gagal menghapus data di database biner'));

// D. Stubbing berdasarkan argumen spesifik
when(() => mockRepository.getProductById('PROD-123'))
    .thenAnswer((_) async => ProductModel(id: 'PROD-123', name: 'Mouse', price: 50000.0));

3. Teknik Verifikasi Call (verify) #

Setelah aksi dijalankan, kita wajib memverifikasi interaksi antar kelas untuk memastikan tidak ada pemanggilan fungsi siluman yang tidak diinginkan:

// Memastikan metode dipanggil tepat satu kali
verify(() => mockRepository.getProductsList()).called(1);

// Memastikan metode dengan argumen apa pun dipanggil minimal sekali
verify(() => mockRepository.deleteProduct(any())).called(greaterThanOrEqualTo(1));

// Memastikan metode tertentu tidak pernah dipanggil sama sekali
verifyNever(() => mockRepository.clearDatabase());

// Memeriksa urutan pemanggilan metode secara ketat
verifyInOrder([
  () => mockRepository.checkSessionValidity(),
  () => mockRepository.getProductsList(),
]);

Pengujian Fungsi Murni (Pure Functions) #

Fungsi murni (pure functions) adalah fungsi yang memiliki sifat deterministik: jika diberikan input yang sama, fungsi tersebut akan selalu menghasilkan output yang sama tanpa mengubah state program di luar dirinya (no side effects). Pengujian fungsi murni adalah jenis pengujian yang paling mudah ditulis karena kita tidak memerlukan objek mock sama sekali.

Mari kita lihat contoh implementasi kelas kalkulator diskon toko:

// lib/features/checkout/domain/helpers/discount_calculator.dart

class DiscountCalculator {
  static double calculateNetPrice(double originalPrice, double discountPercentage) {
    if (originalPrice < 0 || discountPercentage < 0 || discountPercentage > 100) {
      throw ArgumentError('Input harga atau persentase diskon tidak valid');
    }
    final double discountAmount = originalPrice * (discountPercentage / 100);
    return originalPrice - discountAmount;
  }

  static double applyPromoCode(double totalAmount, String? promoCode) {
    if (promoCode == null) return totalAmount;
    
    return switch (promoCode.toUpperCase()) {
      'DISKON10' => totalAmount * 0.90,
      'DISKON50' => totalAmount * 0.50,
      'POTONGAN20K' => totalAmount >= 50000 ? totalAmount - 20000 : totalAmount,
      _ => totalAmount,
    };
  }
}

Berikut adalah unit test lengkap untuk memverifikasi seluruh kemungkinan kondisi (edge cases) dari fungsi murni di atas:

// test/features/checkout/domain/helpers/discount_calculator_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:flutter_app/features/checkout/domain/helpers/discount_calculator.dart';

void main() {
  group('Pengujian DiscountCalculator', () {
    group('calculateNetPrice', () {
      test('Harus menghitung harga bersih setelah diskon dengan benar', () {
        // Arrange, Act, Assert disatukan dalam satu baris untuk efisiensi fungsi murni
        expect(DiscountCalculator.calculateNetPrice(100000.0, 10.0), equals(90000.0));
        expect(DiscountCalculator.calculateNetPrice(250000.0, 20.0), equals(200000.0));
      });

      test('Harus mengembalikan harga asli jika diskon 0%', () {
        expect(DiscountCalculator.calculateNetPrice(50000.0, 0.0), equals(50000.0));
      });

      test('Harus melempar ArgumentError jika input persentase diskon di luar batas', () {
        expect(
          () => DiscountCalculator.calculateNetPrice(100000.0, -5.0),
          throwsA(isA<ArgumentError>()),
        );
        expect(
          () => DiscountCalculator.calculateNetPrice(100000.0, 105.0),
          throwsA(isA<ArgumentError>()),
        );
      });
    });

    group('applyPromoCode', () {
      test('Harus memotong harga sebesar 10% jika menggunakan promo DISKON10', () {
        expect(DiscountCalculator.applyPromoCode(100000.0, 'DISKON10'), equals(90000.0));
      });

      test('Harus memotong harga sebesar 20.000 jika total belanja memenuhi syarat minimum promo POTONGAN20K', () {
        // Memenuhi syarat (>= 50.000)
        expect(DiscountCalculator.applyPromoCode(60000.0, 'POTONGAN20K'), equals(40000.0));
        
        // Tidak memenuhi syarat (< 50.000)
        expect(DiscountCalculator.applyPromoCode(30000.0, 'POTONGAN20K'), equals(30000.0));
      });

      test('Harus mengembalikan harga awal jika kode promo tidak dikenal atau bernilai null', () {
        expect(DiscountCalculator.applyPromoCode(100000.0, 'KODE_PALSU'), equals(100000.0));
        expect(DiscountCalculator.applyPromoCode(100000.0, null), equals(100000.0));
      });
    });
  });
}

Pengujian AsyncNotifier Riverpod via ProviderContainer #

Menguji kelas pengelola state (state management) adalah area di mana pengembang sering kali melakukan kesalahan dengan merender widget UI secara tidak perlu. Di Riverpod, kita dapat menguji logika dan siklus perubahan state dari AsyncNotifier atau Notifier secara murni sebagai unit test menggunakan ProviderContainer.

Pola pengujian ini mensimulasikan bagaimana Riverpod mengelola siklus hidup provider di memori RAM tanpa memerlukan interaksi dengan widget tree Flutter.

Berikut adalah unit test lengkap untuk menguji AsyncNotifier produk:

// test/features/products/presentation/providers/product_notifier_test.dart

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:flutter_app/features/products/domain/repositories/product_repository.dart';
import 'package:flutter_app/features/products/presentation/providers/product_notifier.dart';
import 'package:flutter_app/features/products/data/models/product_model.dart';

// Mock kelas repositori
class MockProductRepository extends Mock implements ProductRepository {}

// Helper Mock Listener untuk mendengarkan perubahan state secara berurutan
class MockListener<T> extends Mock {
  void call(T? previous, T next);
}

void main() {
  group('Pengujian ProductNotifier (Riverpod)', () {
    late MockProductRepository mockRepository;

    setUp(() {
      mockRepository = MockProductRepository();
    });

    // Helper untuk membuat ProviderContainer dengan override dependency
    ProviderContainer makeContainer() {
      final container = ProviderContainer(
        overrides: [
          // Timpa repositori asli dengan instance mock
          productRepositoryProvider.overrideWithValue(mockRepository),
        ],
      );
      // Pastikan container dibersihkan setelah tes selesai
      addTearDown(container.dispose);
      return container;
    }

    test('Harus memuat data produk saat inisialisasi awal (build)', () async {
      // Arrange
      final listProdukDummy = [
        ProductModel(id: '1', name: 'Monitor LCD', price: 2000000.0),
      ];
      when(() => mockRepository.getProductsList()).thenAnswer((_) async => listProdukDummy);

      final container = makeContainer();

      // Act: Membaca Future dari provider untuk memaksa eksekusi inisiasi
      final List<ProductModel> hasil = await container.read(productListProvider.future);

      // Assert
      expect(hasil, equals(listProdukDummy));
      verify(() => mockRepository.getProductsList()).called(1);
    });

    test('Harus menangkap urutan perubahan state (Loading -> Data)', () async {
      // Arrange
      final listProdukDummy = [
        ProductModel(id: '1', name: 'Monitor LCD', price: 2000000.0),
      ];
      when(() => mockRepository.getProductsList()).thenAnswer((_) async => listProdukDummy);

      final container = makeContainer();
      
      // Buat listener tiruan
      final listener = MockListener<AsyncValue<List<ProductModel>>>();

      // Hubungkan listener ke provider
      container.listen(
        productListProvider,
        listener.call,
        fireImmediately: true, // Langsung picu pemanggilan pertama saat didengar
      );

      // Assert: Verifikasi status awal harus berupa loading
      verify(() => listener(null, const AsyncLoading<List<ProductModel>>())).called(1);

      // Tunggu hingga operasi asinkron selesai
      await container.read(productListProvider.future);

      // Assert: Verifikasi status akhir berubah menjadi data
      verify(() => listener(
            const AsyncLoading<List<ProductModel>>(),
            AsyncValue.data(listProdukDummy),
          )).called(1);
    });

    test('Harus memancarkan AsyncError jika pemanggilan repositori gagal', () async {
      // Arrange
      final exception = Exception('Jaringan bermasalah');
      when(() => mockRepository.getProductsList()).thenThrow(exception);

      final container = makeContainer();
      final listener = MockListener<AsyncValue<List<ProductModel>>>();

      container.listen(
        productListProvider,
        listener.call,
        fireImmediately: true,
      );

      // Tunggu siklus microtask selesai untuk memproses penanganan error
      await Future.delayed(Duration.zero);

      // Assert
      verify(() => listener(
            any(that: isA<AsyncLoading>()),
            any(that: isA<AsyncError>()),
          )).called(1);
    });
  });
}

Pola di atas membuktikan bahwa pengujian AsyncNotifier menggunakan ProviderContainer dikombinasikan dengan helper MockListener sangatlah ampuh untuk memverifikasi mesin logika state management kita secara murni di level unit.

Pengujian State Manager BLoC & Cubit #

Bagi proyek yang memilih arsitektur BLoC (Business Logic Component) atau Cubit, komunitas Flutter menyediakan pustaka pendukung pengujian yang sangat matang bernama bloc_test. Pustaka ini menyederhanakan proses simulasi pemanggilan event (act) dan memverifikasi daftar emisi state secara berurutan (expect).

Berikut adalah contoh unit test untuk menguji Cubit produk:

// test/features/products/presentation/cubits/product_cubit_test.dart

import 'package:bloc_test/bloc_test.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:flutter_app/features/products/domain/repositories/product_repository.dart';
import 'package:flutter_app/features/products/presentation/cubits/product_cubit.dart';
import 'package:flutter_app/features/products/presentation/cubits/product_state.dart';
import 'package:flutter_app/features/products/data/models/product_model.dart';

class MockProductRepository extends Mock implements ProductRepository {}

void main() {
  group('Pengujian ProductCubit (BLoC/Cubit)', () {
    late MockProductRepository mockRepository;

    setUp(() {
      mockRepository = MockProductRepository();
    });

    // blocTest: Fungsi pembantu khusus untuk menguji daur hidup BLoC/Cubit
    blocTest<ProductCubit, ProductState>(
      'Harus memancarkan state [Loading, Success] ketika pengambilan data berhasil',
      // build: Membuat instance Cubit yang akan diuji
      build: () => ProductCubit(mockRepository),
      // setUp: Mengatur kondisi stubbing
      setUp: () {
        final listDummy = [ProductModel(id: '1', name: 'Mouse', price: 50000.0)];
        when(() => mockRepository.getProductsList()).thenAnswer((_) async => listDummy);
      },
      // act: Memilih aksi / fungsi yang dipicu oleh UI
      act: (ProductCubit cubit) => cubit.loadProductsFromDatabase(),
      // expect: Mendeklarasikan daftar ekspektasi emisi state secara berurutan
      expect: () => [
        const ProductState.loading(),
        ProductState.success([ProductModel(id: '1', name: 'Mouse', price: 50000.0)]),
      ],
      // verify: Melakukan verifikasi interaksi setelah semua state ter-emit
      verify: (ProductCubit cubit) {
        verify(() => mockRepository.getProductsList()).called(1);
      },
    );

    blocTest<ProductCubit, ProductState>(
      'Harus memancarkan state [Loading, Error] ketika pemanggilan database gagal',
      build: () => ProductCubit(mockRepository),
      setUp: () {
        when(() => mockRepository.getProductsList()).thenThrow(Exception('Database rusak'));
      },
      act: (ProductCubit cubit) => cubit.loadProductsFromDatabase(),
      expect: () => [
        const ProductState.loading(),
        const ProductState.error('Database rusak'),
      ],
    );
  });
}

Menggunakan blocTest menghindarkan kita dari keharusan menulis sinkronisasi stream controller secara manual yang berpotensi memicu kegagalan tes karena timing issue (asynchronous delays).

Cheat Sheet Matchers di Flutter #

Sistem pengujian Dart menyediakan ratusan Matcher yang bertugas membandingkan nilai aktual dengan nilai ekspektasi secara deklaratif. Memahami jenis-jenis matcher akan membantu kita menulis asersi (assertion) yang ekspresif.

Berikut adalah lembar contek (cheat sheet) matcher yang paling sering digunakan dalam unit testing:

// ==========================================
// 1. KESETARAAN & IDENTITAS
// ==========================================
expect(actual, equals(expected));       // Membandingkan kesetaraan nilai (value equality)
expect(actual, same(expected));         // Membandingkan kesetaraan referensi memori (identity equality)
expect(actual, isNull);                 // Memastikan nilai bernilai null
expect(actual, isNotNull);              // Memastikan nilai tidak null
expect(actual, isTrue);                 // Memastikan nilai boolean true
expect(actual, isFalse);                // Memastikan nilai boolean false

// ==========================================
// 2. KELOMPOK ANGKA (NUMERIC)
// ==========================================
expect(actual, greaterThan(10));        // > 10
expect(actual, lessThanOrEqualTo(100)); // <= 100
expect(actual, inInclusiveRange(1, 5)); // Angka ada di rentang 1 s.d 5
expect(actual, closeTo(3.14, 0.01));    // Membandingkan double dengan toleransi eror desimal

// ==========================================
// 3. PENCARIAN TEKS (STRING)
// ==========================================
expect(actual, contains('flutter'));    // Teks mengandung substring 'flutter'
expect(actual, startsWith('Prefix'));   // Teks diawali dengan kata 'Prefix'
expect(actual, endsWith('!'));          // Teks diakhiri dengan tanda seru '!'
expect(actual, matches(r'^\d{3}$'));    // Mencocokkan teks dengan ekspresi reguler (Regex)

// ==========================================
// 4. STRUKTUR DATA (COLLECTIONS)
// ==========================================
expect(actualList, hasLength(3));       // Jumlah item dalam list harus tepat 3
expect(actualList, isEmpty);            // List harus kosong
expect(actualList, isNotEmpty);         // List tidak boleh kosong
expect(actualList, contains('Apple'));  // List mengandung item 'Apple'
expect(actualList, containsAll(['A', 'B'])); // List mengandung semua item A dan B
expect(actualMap, containsPair('code', 200)); // Map memiliki pasangan key 'code' bernilai 200

// ==========================================
// 5. PENANGANAN ASINKRON & EXCEPTION
// ==========================================
// Memastikan fungsi melempar pengecualian (Exception) tipe tertentu saat dijalankan
expect(() => kalkulator.bagi(5, 0), throwsA(isA<UnsupportedError>()));

// Memastikan Future asinkron selesai dengan nilai sukses yang diharapkan
await expectLater(futureCall, completion(equals('Sukses')));

// Memastikan Stream memancarkan data sesuai urutan yang diharapkan
await expectLater(streamCall, emitsInOrder([1, 2, 3]));

Ringkasan #

Kecepatan & Isolasi: Unit test harus berjalan murni di atas Dart VM dalam milidetik tanpa merender komponen UI atau memanggil API jaringan asli.
AAA Pattern: Selalu terapkan pola Arrange (siapkan instansiasi & mock), Act (panggil fungsi target), dan Assert (verifikasi hasil & interaksi).
Mocktail Tanpa Generator: Gunakan pustaka Mocktail untuk membuat stubbing method asinkron (thenAnswer) atau sinkron (thenReturn) secara instan tanpa code generation.
Riverpod Tanpa UI: Gunakan ProviderContainer dan MockListener untuk menguji daur hidup state AsyncNotifier secara deterministik pada tingkat unit.
BLoC / Cubit Test: Manfaatkan pustaka pendukung bloc_test untuk menguji Cubit/BLoC secara aman guna menghindari isu sinkronisasi aliran data (stream timing issues).
Penggunaan Matchers: Kuasai cheat sheet asersi seperti isA<T>(), throwsA(), completion(), dan emitsInOrder() untuk memverifikasi logika asinkron secara akurat.

← Sebelumnya: Overview Berikutnya: Widget Test →