Best Practice #

// ANTI-PATTERN: test implementasi internal
test('_cachedProduk diisi setelah fetch', () async {
  await repository.getProduk();
  // Mengakses field private -- mengikat test ke detail implementasi!
  expect(repository._cachedProduk, isNotEmpty);
});

// BENAR: test perilaku yang terlihat dari luar
test('panggilan kedua tidak hit network jika cache valid', () async {
  when(() => mockRemote.getProduk()).thenAnswer((_) async => produkList);
  when(() => mockLocal.getCachedProduk()).thenAnswer((_) async => produkList);

  await repository.getProduk();  // panggilan pertama
  await repository.getProduk();  // panggilan kedua

  // Remote hanya dipanggil sekali -- cache digunakan di panggilan kedua
  verify(() => mockRemote.getProduk()).called(1);
});

// ANTI-PATTERN: banyak assertion yang tidak berkaitan
test('login', () async {
  final result = await authRepo.login('[email protected]', 'pass');
  expect(result.user.nama, 'Budi');            // assertion 1
  expect(result.accessToken, isNotEmpty);       // assertion 2
  expect(result.expiresIn, greaterThan(0));     // assertion 3
  expect(result.user.email, '[email protected]');  // assertion 4
  // Jika assertion 2 gagal, assertion 3 dan 4 tidak dijalankan
});

// BENAR: pisahkan menjadi test yang fokus
group('login berhasil', () {
  late AuthResult result;

  setUp(() async {
    result = await authRepo.login('[email protected]', 'pass');
  });

  test('mengembalikan user yang benar', () {
    expect(result.user.nama, 'Budi');
    expect(result.user.email, '[email protected]');
  });

  test('mengembalikan token yang valid', () {
    expect(result.accessToken, isNotEmpty);
    expect(result.expiresIn, greaterThan(0));
  });
});

// ANTI-PATTERN: nama yang tidak informatif
test('test 1', () { ... });
test('getProduk', () { ... });
test('error', () { ... });

// BENAR: nama yang mendeskripsikan skenario dan ekspektasi
test('getProduk mengembalikan list kosong jika database kosong', () { ... });
test('getProduk throw NetworkException jika tidak ada koneksi', () { ... });
test('tambahProduk memanggil remote dan invalidate cache', () { ... });
test('hapusProduk dengan ID yang tidak ada throw NotFoundException', () { ... });

// Format yang baik: "[method/fitur] [kondisi] [ekspektasi]"
// atau: "[skenario] [hasil yang diharapkan]"

// ANTI-PATTERN: bergantung pada waktu nyata
test('token expired setelah 1 jam', () async {
  final token = await authService.generateToken();
  await Future.delayed(const Duration(hours: 1));  // JANGAN! Sangat lambat
  expect(authService.isTokenExpired(token), isTrue);
});

// BENAR: mock waktu atau inject clock
class FakeClock implements Clock {
  DateTime _now;
  FakeClock(this._now);
  @override DateTime now() => _now;
  void advance(Duration duration) => _now = _now.add(duration);
}

test('token expired setelah 1 jam', () {
  final clock = FakeClock(DateTime(2024, 1, 1, 10, 0, 0));
  final authService = AuthService(clock: clock);
  final token = authService.generateToken();

  clock.advance(const Duration(hours: 1, minutes: 1));
  expect(authService.isTokenExpired(token), isTrue);
});

// ANTI-PATTERN: bergantung pada urutan test
// Test A menyimpan data ke storage yang dibaca Test B
// Jika Test B jalan duluan, ia gagal

// BENAR: setiap test bersih dari state test lain
setUp(() {
  // Reset semua mock dan state
  reset(mockRepo);
  clearInteractions(mockRepo);
});

// ANTI-PATTERN: delay nyata dalam unit test
test('retry setelah 5 detik', () async {
  await Future.delayed(const Duration(seconds: 5));  // JANGAN!
  // ...
});

// BENAR: gunakan FakeAsync untuk kontrol waktu tanpa menunggu
import 'package:fake_async/fake_async.dart';

test('retry setelah 5 detik (dengan FakeAsync)', () {
  fakeAsync((async) {
    var retryCalled = false;

    RetryService().retry(
      onRetry: () => retryCalled = true,
      delay: const Duration(seconds: 5),
    );

    // Majukan waktu secara sinkron tanpa menunggu
    async.elapse(const Duration(seconds: 6));

    expect(retryCalled, isTrue);
  });
});

void main() {
  group('ProdukNotifier', () {
    late ProviderContainer container;
    late MockProdukRepository mockRepo;

    setUp(() {
      // Buat instance baru untuk SETIAP test
      mockRepo = MockProdukRepository();
      container = ProviderContainer(
        overrides: [produkRepositoryProvider.overrideWithValue(mockRepo)],
      );
    });

    tearDown(() {
      // Selalu dispose container untuk mencegah memory leak
      container.dispose();
    });

    // Setiap test punya container dan mock yang bersih
    test('test 1', () async {
      when(() => mockRepo.getProduk()).thenAnswer((_) async => []);
      final result = await container.read(produkProvider.future);
      expect(result, isEmpty);
    });

    test('test 2', () async {
      // Tidak terpengaruh oleh test 1
      when(() => mockRepo.getProduk()).thenAnswer((_) async => produkList);
      final result = await container.read(produkProvider.future);
      expect(result, equals(produkList));
    });
  });
}

// Tambahkan komentar untuk exclude dari coverage
// coverage:ignore-file  -- exclude seluruh file
// coverage:ignore-line  -- exclude satu baris
// coverage:ignore-start / coverage:ignore-end  -- exclude blok

// lib/core/generated/router.gr.dart
// coverage:ignore-file  -- generated code tidak perlu ditest

# Konfigurasi coverage di flutter_test_coverage.yaml
# atau gunakan lcov --remove untuk exclude pattern

// TIDAK PERLU DITEST:

// 1. Getter/setter trivial tanpa logika
class Produk {
  final String nama;
  String get displayNama => nama;  // tidak perlu ditest
}

// 2. Code yang hanya meneruskan ke library lain
class Logger {
  void log(String message) {
    debugPrint(message);  // tidak perlu test debugPrint
  }
}

// 3. Constructor tanpa logika
class AppConfig {
  final String baseUrl;
  const AppConfig({required this.baseUrl});  // tidak ada yang perlu ditest
}

// 4. Code third-party yang sudah ditest oleh maintainernya
// Jangan test behavior Riverpod atau Dio -- sudah ada test suite mereka sendiri

// PERLU DITEST:
// ✓ Validasi input yang kompleks
// ✓ Transformasi data (DTO → domain entity)
// ✓ State machine (semua transisi state)
// ✓ Edge case (nilai nol, list kosong, null)
// ✓ Error path yang mudah dilupakan

// ✗ Mock terlalu dalam -- mock semuanya termasuk yang tidak perlu
class TestTerlaloBanyakMock {
  void test() {
    final mockA = MockA();
    final mockB = MockB();
    final mockC = MockC();
    final mockD = MockD();
    // 10 mock hanya untuk test satu method sederhana
    // Sinyal: unit yang ditest terlalu besar dan kompleks
  }
}
// ✓ Jika butuh banyak mock, pertimbangkan refactor unit yang ditest

// ✗ Test yang bergantung satu sama lain
test('setup data', () async {
  await db.insert(produk);  // disimpan untuk test berikutnya
});
test('baca data', () async {
  final result = await db.getAll();  // berharap data dari test sebelumnya ada
  expect(result, isNotEmpty);        // bisa gagal jika dijalankan sendiri!
});
// ✓ Setiap test mandiri -- siapkan datanya sendiri di setUp atau dalam test

// ✗ Assertion yang tidak pernah gagal
test('hapus produk', () async {
  await repository.hapusProduk('123');
  // Tidak ada assertion! Test ini selalu lulus meski method throw exception
});
// ✓ Selalu verifikasi efek samping
test('hapus produk', () async {
  await repository.hapusProduk('123');
  verify(() => mockRemote.hapusProduk('123')).called(1);
  verify(() => mockLocal.clearCache()).called(1);
});

// ✗ Sleep di test
test('loading selesai', () async {
  await Future.delayed(const Duration(seconds: 2));  // JANGAN
  expect(find.byType(CircularProgressIndicator), findsNothing);
});
// ✓ Gunakan pumpAndSettle atau waitUntilGone
await tester.pumpAndSettle();
await $(#loadingIndicator).waitUntilGone();