Mengatasi Flaky State Env Menggunakan World Model

Flaky test pada pipeline integrasi dan end-to-end sering kali bersumber dari state drift pada dependensi eksternal, latensi jaringan non-deterministik, atau data yang tertinggal dari eksekusi tes sebelumnya. Penggunaan mock statis sering gagal merefleksikan perubahan status multi-langkah yang kompleks. Di sinilah pendekatan world model untuk simulasi test digunakan.

World model dalam testing berfungsi sebagai representasi internal sistem eksternal yang mempertahankan riwayat (stateful) dan mengeksekusi transisi status prediktif berbasis aturan formal. Pendekatan ini memvalidasi edge-case seperti kegagalan idempotensi, out-of-order webhook, dan timeout secara konsisten.

Batas Determinisme: World Model vs Mock Konvensional

Mock konvensional (misalnya via Jest atau unittest.mock) beroperasi pada level fungsi atau HTTP stubbing sederhana. Stub mengembalikan respons y untuk input x, tanpa memperhitungkan side-effect akumulatif.

  • Stateless Mocking: Cepat diatur tetapi rentan memicu false positives. Mock tidak memvalidasi konkurensi atau kegagalan yang terjadi akibat urutan operasi (sequence-dependent bugs).
  • World Model (Simulated State Machine): Menjaga status internal (seperti saldo, kuota, atau lifecycle resource) dan mengembalikan respons yang konsisten berdasarkan riwayat eksekusi sebelumnya, menjamin determinisme 100%.

Arsitektur Verifikasi Loop Tertutup (Closed-Loop Testing)

Untuk mencegah divergence antara sistem yang diuji (SUT - System Under Test) dan lingkungan uji, arsitektur closed-loop menerapkan siklus validasi tiga tahap:

  1. Action: SUT mengirimkan perintah mutasi status ke model simulasi.
  2. State Transition: World model memproses event, memperbarui internal state, dan mencatat telemetry log.
  3. Observation & Assertion: Pengujian memvalidasi baik respons API maupun snapshot status akhir model untuk memastikan konsistensi mutasi.

Implementasi State Transisi Prediktif Sederhana

Berikut implementasi world model deterministik untuk simulasi payment gateway dengan penanganan race condition dan pembatalan transaksi menggunakan Python.

from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, Optional

class PaymentStatus(Enum):
    PENDING = "PENDING"
    CAPTURED = "CAPTURED"
    FAILED = "FAILED"
    REFUNDED = "REFUNDED"

@dataclass
class Transaction:
    id: str
    amount: int
    status: PaymentStatus = PaymentStatus.PENDING

class PaymentGatewayWorldModel:
    """Model simulasi status tertutup untuk dependensi pembayaran eksternal."""
    def __init__(self, failure_budget_id: Optional[str] = None):
        self.transactions: Dict[str, Transaction] = {}
        self.failure_budget_id = failure_budget_id

    def process_charge(self, tx_id: str, amount: int) -> Transaction:
        # Simulasi penanganan idempotensi duplikat
        if tx_id in self.transactions:
            return self.transactions[tx_id]

        if tx_id == self.failure_budget_id:
            tx = Transaction(id=tx_id, amount=amount, status=PaymentStatus.FAILED)
        else:
            tx = Transaction(id=tx_id, amount=amount, status=PaymentStatus.CAPTURED)

        self.transactions[tx_id] = tx
        return tx

    def process_refund(self, tx_id: str) -> Transaction:
        tx = self.transactions.get(tx_id)
        if not tx:
            raise KeyError(f"Transaction {tx_id} not found")
        
        # Validasi aturan transisi domain secara ketat
        if tx.status != PaymentStatus.CAPTURED:
            raise ValueError(f"Cannot refund transaction in status {tx.status}")

        tx.status = PaymentStatus.REFUNDED
        return tx

# Runnable self-check
if __name__ == "__main__":
    model = PaymentGatewayWorldModel(failure_budget_id="tx_err")
    
    # 1. Capture success
    t1 = model.process_charge("tx_100", 5000)
    assert t1.status == PaymentStatus.CAPTURED

    # 2. Idempotency assertion
    t1_dup = model.process_charge("tx_100", 5000)
    assert t1_dup.status == PaymentStatus.CAPTURED

    # 3. Controlled failure
    t2 = model.process_charge("tx_err", 2000)
    assert t2.status == PaymentStatus.FAILED

    # 4. State-dependent transition
    t1_refunded = model.process_refund("tx_100")
    assert t1_refunded.status == PaymentStatus.REFUNDED

    # 5. Invalid transition rejection
    try:
        model.process_refund("tx_err")
        assert False, "Should fail invalid refund"
    except ValueError:
        pass
Catatan: Implementasi di atas menghindari dependency external. Jalankan via python3 model.py langsung pada environment CI tanpa setup infrastruktur tambahan.

Evaluasi dan Trade-off

Mengadopsi model simulasi lingkungan memberikan keuntungan signifikan sekaligus beban pemeliharaan tertentu:

  • Keuntungan: Menghilangkan dependensi jaringan nyata di CI, eksekusi tes berjalan dalam satuan milidetik, dan reproducing edge case (seperti network timeouts atau concurrency deadlock) dapat diotomasi via seed status tertentu.
  • Risiko Drift: Apabila spesifikasi sistem nyata diperbarui tetapi world model tidak disinkronisasi, tes akan tetap lulus (false positive). Perlu kontrak OpenAPI/gRPC yang sinkron antara service riil dan model pengujian.
  • Biaya Perawatan: World model membutuhkan kode tersendiri yang harus dirawat. Pendekatan ini ideal untuk sistem inti (core billing, ledger, orchestrator) bukan untuk integrasi CRUD standar.