Belajar Software Architecture and Design Patterns - Testing Strategy per Arsitektur | Belajar Software Architecture and Design Patterns

#Pendahuluan

Arsitektur yang kita bangun sepanjang series menyimpan bonus yang jarang diiklankan: ia sangat mudah dites — justru karena itulah hexagonal/clean dirancang. Episode ini merumuskan strategi test yang memetakan setiap level arsitektur ke jenis test paling efektifnya, sehingga suite cepat, stabil, dan menakutinya refactor hilang.

#Konsep

#Piramida Test untuk Arsitekturnya

100%

Pemetaan lapis arsitektur → jenis test:

Lapis	Jenis Test	Infrastruktur
Domain (aggregate/VO)	Unit murni	Tidak ada — memori
Application (use case)	Unit + fake port	In-memory adapter (ep.15)
Infrastructure (repo/mailer)	Integration	Postgres/broker sungguhan
Antar modul/context	Contract test	Schema API/event
Struktur kode itu sendiri	Architecture test	dependency-cruiser/lint gate (ep.13–16)

Prinsip alokasi biaya: makin ke atas piramida makin mahal dan rapuh — karena itu E2E hanya jalur checkout utama; kepastian logika dijamin lapis bawah.

#Unit Domain Murni & Contract Test

Domain murni: aggregate Order dari ep.19 sudah membuktikannya — kasus perilaku diuji tanpa framework, durasi total ratusan milidetik.
Contract test antar modul: skema public API/event (OrderPlaced dst.) diverifikasi dari dua sisi (publisher & consumer), sehingga perubahan pemecah kontrak ketahuan sebelum deploy — versi mini pendekatan Pact.

#Real-World Implementasi

describe('PlaceOrder use case', () => {
  it('menyimpan order & merekam domain event', async () => {
    const repo = new InMemoryOrders();          // driven port palsu
    const bus = new SpyEventBus();
    const uc = new PlaceOrder(repo, bus);
 
    const res = await uc.exec({ customerId: 'c1',
      items: [item('SKU-A', 2, Money.of(50000, 'IDR'))] });
 
    expect((await repo.byId(res.orderId))!.status).toBe('placed');
    expect(bus.published).toContainEqual(expect.objectContaining(
      { type: 'OrderPlaced' }));
  });
});
// Nol database. Nol HTTP. Milidetik per kasus.

func TestPlaceOrderHandler(t *testing.T) {
    assert := assert.New(t)
    repo := NewFakeOrders()
    app := fiber.New()
    httpadapter.Register(app, usecase.NewPlaceOrder(repo))
 
    req := httptest.NewRequest("POST", "/orders",
        strings.NewReader(`{"customerId":"c1","items":[...]}`))
    res, _ := app.Test(req, -1)                 // full stack HTTP tanpa socket
 
    assert.Equal(201, res.StatusCode)
    saved, _ := repo.ByID(context.Background(), extractID(res))
    assert.Equal(ordering.Placed, saved.Status)
}

it('membuat order via API', function () {
    Http::fake(['payments.example/*' => Http::response(['id' => 'trx1'])]);
    $this->seed(ProductsSeeder::class);         // trait RefreshDatabase
 
    $res = $this->postJson('/api/orders', validPayload());
 
    $res->assertCreated()->assertJsonPath('status', 'placed');
    expect(OrderModel::count())->toBe(1);
});
it('menolak keranjang kosong', fn () =>
    $this->postJson('/api/orders', ['items' => []])->assertUnprocessable());

Perhatikan gradasinya: contoh NestJS/Go adalah use case test dengan fake (tanpa DB), contoh Laravel adalah integration/API test dengan DB sungguhan — level piramida berbeda, keduanya sama-sama dibutuhkan dalam suite yang sehat.

#Praktik

Target outline: satu use case (PlaceOrder) ditest di 3 level tanpa DB sungguhan di unit layer.

LEVEL 1 - UNIT DOMAIN (aggregate):
  add/remove item, invarian locked/kosong/cancel, pull events - memori murni
LEVEL 2 - USE CASE (fake port):
  PlaceOrder(InMemoryRepo, SpyBus): happy path + pricing gagal + SKU dobel
  -> assert state & event, TANPA database
LEVEL 3 - INTEGRATION/E2E:
  HTTP nyata -> controller -> use case -> REPO SUNGGUHAN (Postgres)
  -> assert response + row DB + event masuk outbox
 
Aturan piramida: hitung test tiap level - harus MENGECHIL ke atas
(mis. 12 : 6 : 2). Kalau e2e paling banyak, piramidamu terbalik.

[x] Level 1: >= 6 kasus aggregate, total di bawah ratusan ms
[x] Level 2: nol import ORM/framework di file test use case
[x] Level 3: 1-2 jalur utama SAJA (bukan semua kombinasi)
[x] Architecture test (ep.13/16) tetap hijau - struktur terjaga
[x] Contract: schema OrderPlaced divalidasi publisher + consumer
[x] CI menjalankan ketiganya; level bawah paralel & cepat

Tip

Metrik sehat untuk ditagih tiap retro: median durasi suite unit-domain harus tetap di bawah 5 detik walau jumlah test bertambah. Jika membengkak, hampir pasti ada dependensi infrastruktur yang menyelinap masuk ke level yang salah.

#Penutup

Rangkuman episode ini:

Piramida dipetakan ke lapis arsitektur: domain murni → use case+fake → integration adapter → E2E minim → architecture test sebagai pagar.
Ketiga ekosistem matang alatnya: Jest, testing+httptest Go, PHPUnit/Pest Laravel — polanya identik.
Latihan tiga-level membuktikan klaim series ini: arsitektur yang benar membuat testing murah.

Episode 24 belajar dari kegagalan orang lain: Anti-Patterns & Refactoring Legacy Codebase — god object sampai distributed monolith, dan strategi strangler fig dengan characterization test. Sampai jumpa!