Kualitas

BAB 10: Testing dan Debugging

Menulis tes yang berguna dengan Jest dan React Native Testing Library, menelusuri bug dengan debugger, menangkap kesalahan produksi, dan menguji alur penting di perangkat.

Bug di aplikasi mobile mahal. Perbaikannya menunggu rilis berikutnya, dan rilis berikutnya menunggu tinjauan toko aplikasi. Karena itu, biaya menulis tes jauh lebih murah daripada biaya menemukan kesalahan yang sama 3 kali di tangan pengguna.

Bab ini membahas 3 hal yang saling melengkapi: tes otomatis untuk logika, alat debug untuk masalah yang sulit direproduksi, dan pelaporan kesalahan dari perangkat nyata.

Apa yang layak diuji

Tidak semua kode perlu tes. Menulis tes untuk setiap komponen menghasilkan banyak berkas yang harus diperbarui setiap kali tampilan berubah, tanpa menangkap bug berarti.

LapisanLayak diujiAlasan
Fungsi murniya, cakupan tinggicepat, stabil, tidak butuh perangkat
Hook berisi logikayatempat bug state paling sering muncul
Komponen dengan interaksiya, seperlunyamemastikan tombol memanggil aksi yang benar
Tata letak dan gayatidakberubah sering, hasilnya visual
Navigasi antar layarsedikit sajalebih efektif diuji manual atau end to end

Aturan praktisnya: uji keputusan, bukan tampilan. Tes yang memeriksa "tombol simpan memanggil fungsi simpan dengan isi yang benar" berguna bertahun-tahun. Tes yang memeriksa "teks judul berwarna #111827" akan usang dalam sepekan.

Menyiapkan Jest

BashBASH
npx expo install -- --save-dev jest-expo jest @types/jest
npm install --save-dev @testing-library/react-native

Tambahkan konfigurasi di package.json:

{}JSON
{
  "jest": {
    "preset": "jest-expo",
    "setupFilesAfterEnv": ["<rootDir>/jest.setup.ts"],
    "transformIgnorePatterns": [
      "node_modules/(?!((jest-)?react-native|@react-native(-community)?|expo(nent)?|@expo(nent)?/.*|@expo-google-fonts/.*|react-navigation|@react-navigation/.*|@sentry/react-native|native-base|react-native-svg))"
    ]
  }
}

Preset jest-expo menangani sebagian besar modul native. Modul yang belum dikenali bisa ditambahkan ke transformIgnorePatterns, bukan dimatikan seluruhnya.

Berkas jest.setup.ts dipakai untuk hal yang berlaku di semua tes:

TypeScriptTS
import "@testing-library/react-native/extend-expect";

jest.mock("@react-native-async-storage/async-storage", () =>
  require("@react-native-async-storage/async-storage/jest/async-storage-mock"),
);

Menguji fungsi murni

Mulai dari bagian yang paling mudah dan paling sering berisi logika bisnis.

TypeScriptTS
// lib/harga.ts
export function hitungTotal(item: { harga: number; jumlah: number }[], diskonPersen = 0) {
  const subtotal = item.reduce((total, i) => total + i.harga * i.jumlah, 0);
  const diskon = Math.min(Math.max(diskonPersen, 0), 100);
  return Math.round(subtotal * (1 - diskon / 100));
}
TypeScriptTS
// lib/harga.test.ts
import { hitungTotal } from "./harga";

describe("hitungTotal", () => {
  it("menjumlahkan harga dikali jumlah", () => {
    expect(hitungTotal([{ harga: 10_000, jumlah: 2 }, { harga: 5_000, jumlah: 1 }])).toBe(25_000);
  });

  it("menerapkan diskon", () => {
    expect(hitungTotal([{ harga: 10_000, jumlah: 1 }], 10)).toBe(9_000);
  });

  it("mengabaikan diskon di luar batas", () => {
    expect(hitungTotal([{ harga: 10_000, jumlah: 1 }], 150)).toBe(0);
    expect(hitungTotal([{ harga: 10_000, jumlah: 1 }], -20)).toBe(10_000);
  });

  it("mengembalikan nol untuk daftar kosong", () => {
    expect(hitungTotal([])).toBe(0);
  });
});

4 kasus itu menangkap kesalahan yang paling sering: lupa mengalikan jumlah, diskon negatif, dan pembulatan.

Menguji komponen

React Native Testing Library menguji komponen dari sudut pandang pengguna: cari elemen berdasarkan teks atau label, lalu berinteraksi.

React TSXTSX
// components/Penghitung.tsx
import { useState } from "react";
import { Pressable, Text } from "react-native";

export function Penghitung({ awal = 0 }: { awal?: number }) {
  const [angka, setAngka] = useState(awal);

  return (
    <>
      <Text>Nilai: {angka}</Text>
      <Pressable accessibilityRole="button" accessibilityLabel="Tambah" onPress={() => setAngka((n) => n + 1)}>
        <Text>Tambah</Text>
      </Pressable>
    </>
  );
}
React TSXTSX
// components/Penghitung.test.tsx
import { render, screen, userEvent } from "@testing-library/react-native";
import { Penghitung } from "./Penghitung";

describe("Penghitung", () => {
  it("menampilkan nilai awal", () => {
    render(<Penghitung awal={5} />);
    expect(screen.getByText("Nilai: 5")).toBeOnTheScreen();
  });

  it("menambah satu setiap tombol ditekan", async () => {
    const pengguna = userEvent.setup();
    render(<Penghitung />);

    await pengguna.press(screen.getByRole("button", { name: "Tambah" }));
    await pengguna.press(screen.getByRole("button", { name: "Tambah" }));

    expect(screen.getByText("Nilai: 2")).toBeOnTheScreen();
  });
});

Pencarian berdasarkan peran dan nama aksesibilitas membuat tes tetap bertahan ketika tampilan berubah. Mengganti warna atau menambah padding tidak merusak tes.

Menguji kode yang memanggil API

Kode yang bergantung jaringan harus diuji dengan respons tiruan. Tanpa itu, tes gagal ketika server mati, dan hasilnya menyesatkan.

React TSXTSX
// hooks/useCatatan.test.tsx
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { renderHook, waitFor } from "@testing-library/react-native";
import { useCatatan } from "./useCatatan";
import * as api from "../api/catatan";

jest.mock("../api/catatan");
const apiTiruan = api as jest.Mocked<typeof api>;

function bungkus() {
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  return ({ children }: { children: React.ReactNode }) => (
    <QueryClientProvider client={client}>{children}</QueryClientProvider>
  );
}

describe("useCatatan", () => {
  it("mengembalikan daftar setelah dimuat", async () => {
    apiTiruan.ambilCatatan.mockResolvedValue([{ id: "1", judul: "Pertama", isi: "", dibuatPada: "" }]);

    const { result } = renderHook(() => useCatatan(), { wrapper: bungkus() });

    await waitFor(() => expect(result.current.isSuccess).toBe(true));
    expect(result.current.data).toHaveLength(1);
  });

  it("menandai keadaan gagal saat server membalas error", async () => {
    apiTiruan.ambilCatatan.mockRejectedValue(new Error("server:500"));

    const { result } = renderHook(() => useCatatan(), { wrapper: bungkus() });

    await waitFor(() => expect(result.current.isError).toBe(true));
  });
});

retry: false pada QueryClient tes penting. Tanpa itu, tes gagal menunggu percobaan ulang dan berjalan lambat.

Tes komponen native dengan tiruan

Modul seperti kamera dan penyimpanan aman tidak tersedia di lingkungan tes. Buat tiruannya secara eksplisit, lalu periksa pemanggilannya.

TypeScriptTS
jest.mock("expo-secure-store", () => ({
  setItemAsync: jest.fn().mockResolvedValue(undefined),
  getItemAsync: jest.fn().mockResolvedValue("token-contoh"),
  deleteItemAsync: jest.fn().mockResolvedValue(undefined),
}));

import * as SecureStore from "expo-secure-store";
import { bacaToken } from "./sesi";

it("membaca token dari penyimpanan aman", async () => {
  await expect(bacaToken()).resolves.toBe("token-contoh");
  expect(SecureStore.getItemAsync).toHaveBeenCalledWith("sesi.token");
});

Debugging saat aplikasi berjalan

Tes tidak menangkap semua masalah. Untuk masalah yang muncul di perangkat, alat berikut lebih cepat.

AlatKegunaan
Metro logkesalahan JavaScript, peringatan, dan console.log
React DevToolsmemeriksa pohon komponen, props, dan penyebab render ulang
Network inspectormelihat permintaan, status, dan waktu respons
Debugger JavaScripttitik henti dan penelusuran variabel
Layout inspectormemeriksa batas dan ukuran komponen

Kebiasaan yang menghemat waktu: baca log dari baris pertama. Pesan React Native sering panjang, tapi penyebabnya biasanya disebut paling atas.

Untuk bug yang sulit direproduksi, catat dulu 4 informasi ini sebelum mengubah kode: perangkat dan versi sistem, langkah persis yang memicu, apakah terjadi saat aplikasi baru dibuka, dan apakah terjadi saat jaringan mati. Sebagian besar bug bisa dipersempit hanya dengan menjawab 4 hal itu.

Menangkap kesalahan yang tidak terlihat

Aplikasi yang berjalan baik di perangkat pengembang bisa gagal di perangkat pengguna karena memori, izin, atau data yang tidak terduga. Pasang penangkap kesalahan sejak awal.

React TSXTSX
// components/BatasKesalahan.tsx
import { Component, type ReactNode } from "react";
import { Text, View } from "react-native";

type Props = { children: ReactNode };
type State = { galat: Error | null };

export class BatasKesalahan extends Component<Props, State> {
  state: State = { galat: null };

  static getDerivedStateFromError(galat: Error): State {
    return { galat };
  }

  componentDidCatch(galat: Error) {
    // kirim ke layanan pelaporan, tanpa data pribadi
    console.warn("kesalahan komponen:", galat.message);
  }

  render() {
    if (this.state.galat) {
      return (
        <View style={{ padding: 24, gap: 8 }}>
          <Text style={{ fontWeight: "700" }}>Terjadi kesalahan</Text>
          <Text style={{ color: "#64748b" }}>Muat ulang aplikasi. Tim kami sudah menerima laporannya.</Text>
        </View>
      );
    }
    return this.props.children;
  }
}

Untuk pelaporan otomatis, layanan seperti Sentry menyediakan integrasi React Native yang menangkap kesalahan JavaScript dan native. 2 hal yang wajib diatur: kirim source map saat build, dan saring data pribadi sebelum dikirim. Laporan kesalahan tanpa source map hanya berisi tumpukan fungsi yang tidak terbaca.

Tes alur di perangkat

Untuk alur penting seperti masuk, checkout, atau unggah bukti, tes otomatis di perangkat memberi keyakinan yang tidak bisa diberikan unit test. 2 pilihan umum:

AlatPendekatan
Maestroberkas YAML, ringkas, cepat dijalankan
DetoxJavaScript, terintegrasi Jest, lebih banyak kendali

Contoh alur Maestro sederhana:

YMYAML
appId: com.contoh.catatan
---
- launchApp
- tapOn: "Catatan baru"
- inputText: "Rapat mingguan"
- tapOn: "Simpan catatan"
- assertVisible: "Rapat mingguan"

Batasi tes end to end pada 3 sampai 5 alur paling penting. Menulisnya untuk seluruh aplikasi membuat waktu tunggu build menjadi penyebab tes ditinggalkan.

Yang perlu masuk pipeline

Setiap perubahan kode sebaiknya melewati 3 pemeriksaan sebelum digabung:

BashBASH
npm run lint
npx tsc --noEmit
npm test -- --ci

Perintah itu cukup cepat untuk dijalankan pada setiap permintaan gabungan, dan menangkap sebagian besar kesalahan yang tidak terlihat saat menulis kode.

Kesalahan yang sering terjadi

GejalaPenyebabPerbaikan
tes gagal karena waktu habisretry pada query tidak dimatikanset retry: false di QueryClient tes
tes lulus tapi aplikasi rusakhanya menguji tampilanuji keputusan dan pemanggilan aksi
peringatan act(...)pembaruan state di luar awaitgunakan await userEvent dan waitFor
tes berjalan lambatbanyak komponen dirender utuhuji hook dan fungsi secara terpisah
laporan kesalahan tanpa nama berkassource map tidak diunggahunggah source map saat build
tes end to end rapuhmemilih elemen berdasarkan posisipilih berdasarkan teks atau label stabil

Latihan singkat

  1. Tulis tes untuk fungsi yang memformat tanggal, termasuk kasus tanggal tidak valid.
  2. Tulis tes komponen untuk formulir catatan: judul kosong harus menampilkan pesan galat, judul valid harus memanggil aksi simpan.
  3. Pasang penangkap kesalahan, lalu paksa satu komponen melempar error. Pastikan layar pengganti muncul dan aplikasi tidak menutup sendiri.

Ringkasan

Uji keputusan dan logika, bukan warna dan jarak. Jest dengan preset Expo menangani fungsi dan hook, React Native Testing Library menguji komponen dari sudut pandang pengguna, dan tiruan modul native membuat tes tidak bergantung perangkat. Untuk masalah yang tidak tertangkap tes, debugger dan penangkap kesalahan memberi informasi dari perangkat nyata. Alur paling penting diuji end to end, dan seluruhnya dijalankan otomatis sebelum kode digabung.

Bab 11 membahas performa: mengukur sebelum mengubah, menemukan penyebab frame yang terlewat, dan memperbaiki daftar yang tersendat.