Membuat Sistem Auto-Test (TDD): Biarkan AI Menulis Unit Test Sebelum Menulis Kode Fitur

Pendekatan Naif:
Prompt Fitur ───> LLM Buat Kode ───> Run Manual(Error) ───> Prompt Debug Ulang(Kode Tambah Kusut)

Pendekatan AI-TDD:
Prompt Spek ───> LLM Buat Test(PyTest) ───> Kunci Kontrak ───> LLM Buat Kode ───> Run Test(Pass)

[PROMPT KE AI]
Bertindaklah sebagai Senior QA Architect & Python Security Engineer.
Saya ingin kamu membuat berkas test_billing_engine.py menggunakan PyTest.
Jangan tulis kode implementasinya sekarang. Hanya tulis unit test dan integration test.

Spesifikasi Modul `BillingEngine`:
- Method `deduct_credits(org_id: str, amount: Decimal) -> TransactionResult`
- Method `refund_credits(org_id: str, amount: Decimal, original_tx_id: str) -> TransactionResult`
- Method `get_balance(org_id: str) -> Decimal`

Wajib mencakup pengujian:
1. Nominal pecahan desimal presisi tinggi(hindari bug float rounding).
2. Upaya pengurangan saldo melampaui limit(harus raise InsufficientCreditError).
3. Validasi parameter input(nilai negatif, string kosong, tipe data salah).
4. Skenario idempotensi pada refund.

# test_billing_engine.py
import pytest
from decimal import Decimal
from unittest.mock import Mock

# Asumsikan modul belum ada, kita mendefinisikan interface yang diharapkan
from billing_engine import BillingEngine, InsufficientCreditError, InvalidAmountError

@pytest.fixture
def mock_storage():
    """Mock storage layer yang menyimpan saldo in-memory untuk pengujian."""
    storage = {}
    return storage

@pytest.fixture
def billing_service(mock_storage):
    return BillingEngine(storage_adapter=mock_storage, max_credit_cap=Decimal("10000.00"))

def test_deduct_credits_success(billing_service, mock_storage):
    org_id = "org_enterprise_99"
    mock_storage[org_id] = Decimal("500.00")
    
    result = billing_service.deduct_credits(org_id, Decimal("150.50"))
    
    assert result.success is True
    assert result.remaining_balance == Decimal("349.50")
    assert billing_service.get_balance(org_id) == Decimal("349.50")

def test_deduct_credits_insufficient_funds(billing_service, mock_storage):
    org_id = "org_startup_01"
    mock_storage[org_id] = Decimal("50.00")
    
    with pytest.raises(InsufficientCreditError) as exc_info:
        billing_service.deduct_credits(org_id, Decimal("50.01"))
    
    assert "Saldo tidak mencukupi" in str(exc_info.value)
    # Pastikan saldo tidak termutasi saat gagal
    assert billing_service.get_balance(org_id) == Decimal("50.00")

@pytest.mark.parametrize("invalid_amount", [
    Decimal("-10.00"),
    Decimal("0.00"),
    Decimal("-0.0001"),
])
def test_deduct_credits_invalid_amounts(billing_service, invalid_amount):
    with pytest.raises(InvalidAmountError):
        billing_service.deduct_credits("org_any", invalid_amount)

def test_refund_cannot_exceed_max_cap(billing_service, mock_storage):
    org_id = "org_whale_07"
    mock_storage[org_id] = Decimal("9950.00")
    
    # Cap maksimum adalah 10,000.00. Refund 100.00 harus gagal atau ditolak.
    with pytest.raises(ValueError) as exc_info:
        billing_service.refund_credits(org_id, Decimal("100.00"), original_tx_id="tx_123")
    
    assert "Melebihi batas alokasi maksimum" in str(exc_info.value)

$ pytest test_billing_engine.py
ModuleNotFoundError: No module named 'billing_engine'
FAILED test_billing_engine.py - 4 failed in 0.05s

# billing_engine.py
from decimal import Decimal
from dataclasses import dataclass
from typing import Dict, Any

class InsufficientCreditError(Exception):
    pass

class InvalidAmountError(Exception):
    pass

@dataclass(frozen=True)
class TransactionResult:
    success: bool
    remaining_balance: Decimal
    transaction_id: str

class BillingEngine:
    def __init__(self, storage_adapter: Dict[str, Decimal], max_credit_cap: Decimal):
        self.storage = storage_adapter
        self.max_credit_cap = max_credit_cap

    def get_balance(self, org_id: str) -> Decimal:
        return self.storage.get(org_id, Decimal("0.00"))

    def deduct_credits(self, org_id: str, amount: Decimal) -> TransactionResult:
        if amount <= Decimal("0.00"):
            raise InvalidAmountError("Jumlah potongan harus lebih besar dari nol.")
        
        current_balance = self.get_balance(org_id)
        if current_balance < amount:
            raise InsufficientCreditError(f"Saldo tidak mencukupi. Sisa: {current_balance}, Diminta: {amount}")

        new_balance = current_balance - amount
        self.storage[org_id] = new_balance
        
        return TransactionResult(
            success=True,
            remaining_balance=new_balance,
            transaction_id=f"tx_deduct_{org_id}_{len(self.storage)}"
        )

    def refund_credits(self, org_id: str, amount: Decimal, original_tx_id: str) -> TransactionResult:
        if amount <= Decimal("0.00"):
            raise InvalidAmountError("Jumlah refund harus lebih besar dari nol.")

        current_balance = self.get_balance(org_id)
        if (current_balance + amount) > self.max_credit_cap:
            raise ValueError("Melebihi batas alokasi maksimum yang diizinkan.")

        new_balance = current_balance + amount
        self.storage[org_id] = new_balance

        return TransactionResult(
            success=True,
            remaining_balance=new_balance,
            transaction_id=f"tx_refund_{original_tx_id}"
        )

$ pytest test_billing_engine.py
============================== 4 passed in 0.02s ==============================

┌─────────────────────────────────────────────────────────────┐
│                    Local Developer Environment              │
│                                                             │
│   ┌─────────────┐       Prompt Spek       ┌─────────────┐   │
│   │ Spec / Docs │ ──────────────────────> │ Auto-Agent  │   │
│   └─────────────┘                         │ Python CLI  │   │
│          ▲                                └──────┬──────┘   │
│          │                                       │          │
│          │                               Request │ Unified  │
│          │                                Payload│ API Call │
└──────────┼───────────────────────────────────────┼──────────┘
           │                                       ▼
           │                        ┌─────────────────────────┐
           │                        │  AiStudio.id Gateway    │
           │                        │  (Low Latency / Router) │
           │                        └──────────────┬──────────┘
           │                                       │
           │                     ┌─────────────────┴─────────────────┐
           │                     ▼                                   ▼
           │          ┌───────────────────────┐           ┌───────────────────────┐
           │          │ Anthropic Claude 3.7  │           │ Google Gemini 2.0     │
           │          │ (Arsitek Unit Test)   │           │ (Fast Code Patching)  │
           │          └──────────┬────────────┘           └───────────┬───────────┘
           │                     │                                    │
           │                     └─────────────────┬──────────────────┘
           │                                       │ Generated Test / Code
           │                                       ▼
┌──────────┴──────────────────────────────────────────────────┐
│   ┌─────────────────────────────────────────────────────┐   │
│   │ Local Test Execution: `pytest --json-report`        │   │
│   └──────────────────────────┬──────────────────────────┘   │
│                              │                              │
│               ┌──────────────┴──────────────┐               │
│               ▼                             ▼               │
│      [ Exit Code == 0 ]            [ Exit Code != 0 ]       │
│               │                             │               │
│        STATUS: SUCCESS               Kirim Traceback        │
│      (Commit & Refactor)            Kembali ke Gateway      │
│                                    (Loop Maksimal 3x)       │
└─────────────────────────────────────────────────────────────┘

# auto_tdd_runner.py
import subprocess
import os
from openai import OpenAI

# Menggunakan endpoint AiStudio.id API Gateway
client = OpenAI(
    api_key=os.environ.get("AISTUDIO_API_KEY"),
    base_url="https://api.aistudio.id/v1"
)

def run_pytest():
    """Menjalankan pytest dan menangkap stdout/stderr serta exit code."""
    result = subprocess.run(
        ["pytest", "test_billing_engine.py", "-v", "--tb=short"],
        capture_output=True,
        text=True
    )
    return result.returncode, result.stdout

def heal_code_with_ai(test_code: str, broken_code: str, error_log: str) -> str:
    """Mengirim traceback error ke AiStudio.id untuk perbaikan otomatis."""
    prompt = f"""
    Kamu adalah software engineer handal. Unit test berikut ini GAGAL.
    
    === TEST CODE ===
    {test_code}
    
    === CURRENT IMPLEMENTATION ===
    {broken_code}
    
    === PYTEST TRACEBACK ERROR ===
    {error_log}
    
    Perbaiki `billing_engine.py` agar semua pengujian di atas lulus 100%.
    Keluarkan HANYA kode Python murni tanpa markdown, tanpa backticks, tanpa penjelasan.
    """
    
    response = client.chat.completions.create(
        model="claude-3-7-sonnet-20250219",  # Tersedia via routing AiStudio.id
        messages=[{"role": "user", "content": prompt}],
        temperature=0.1
    )
    return response.choices[0].message.content.strip()

def main():
    max_retries = 3
    attempt = 0
    
    with open("test_billing_engine.py", "r") as f:
        test_code = f.read()

    while attempt < max_retries:
        attempt += 1
        print(f"[*] Menjalankan Test Suite(Percobaan ke-{attempt})...")
        
        exit_code, output = run_pytest()
        if exit_code == 0:
            print("[+] SUKSES: Semua unit test berhasil lolos!")
            break
            
        print(f"[!] Test gagal. Mengirimkan output kegagalan ke AiStudio.id Gateway...")
        
        current_code = ""
        if os.path.exists("billing_engine.py"):
            with open("billing_engine.py", "r") as f:
                current_code = f.read()
                
        fixed_code = heal_code_with_ai(test_code, current_code, output)
        
        with open("billing_engine.py", "w") as f:
            f.write(fixed_code)
            
        print("[*] Perbaikan kode telah diterapkan dari AI. Menjalankan verifikasi ulang...")

if __name__ == "__main__":
    main()

from hypothesis import given, strategies as st
from decimal import Decimal

@given(st.decimals(min_value=Decimal("0.01"), max_value=Decimal("1000.00")))
def test_balance_always_decreases_by_exact_amount(billing_service, mock_storage, amount):
    org_id = "org_fuzz"
    mock_storage[org_id] = Decimal("2000.00")
    
    initial = billing_service.get_balance(org_id)
    billing_service.deduct_credits(org_id, amount)
    final = billing_service.get_balance(org_id)
    
    assert initial - final == amount