everything-claude-code/docs/tr/commands/tdd.md

description

description
Test odaklı geliştirme (TDD) iş akışını zorlar. Interface'leri tasarla, ÖNCE testleri oluştur, sonra minimal kodu uygula. %80+ kod kapsama oranı sağla.

TDD Komutu

Bu komut, test odaklı geliştirme metodolojisini zorlamak için tdd-guide agent'ını çağırır.

Bu Komut Ne Yapar

1. Interface'leri Tasarla - Önce tip/interface'leri tanımla
2. Önce Testleri Oluştur - Başarısız testler yaz (RED)
3. Minimal Kod Uygula - Geçmek için yeterli kodu yaz (GREEN)
4. Refactor Et - Testleri yeşil tutarken kodu iyileştir (REFACTOR)
5. Kapsama Oranını Doğrula - %80+ test kapsama oranı sağla

Ne Zaman Kullanılır

/tdd komutunu şu durumlarda kullanın:

• Yeni özellikler uygularken
• Yeni fonksiyonlar/componentler eklerken
• Hataları düzeltirken (önce hatayı tekrar eden test yaz)
• Mevcut kodu refactor ederken
• Kritik iş mantığı oluştururken

Nasıl Çalışır

tdd-guide agent'ı şunları yapacaktır:

1. Giriş/çıkışlar için interface'leri tanımla
2. BAŞARISIZ olacak testleri yaz (çünkü kod henüz yok)
3. Testleri çalıştır ve doğru sebepten başarısız olduklarını doğrula
4. Testleri geçirmek için minimal uygulama yaz
5. Testleri çalıştır ve geçtiklerini doğrula
6. Testleri yeşil tutarken kodu refactor et
7. Kapsama oranını kontrol et ve %80'in altındaysa daha fazla test ekle

TDD Döngüsü

RED → GREEN → REFACTOR → TEKRARLA

RED:      Başarısız bir test yaz
GREEN:    Geçmek için minimal kod yaz
REFACTOR: Kodu iyileştir, testleri geçmeye devam et
TEKRARLA: Bir sonraki özellik/senaryo

Örnek Kullanım

Kullanıcı: /tdd Piyasa likidite skorunu hesaplamak için bir fonksiyona ihtiyacım var

Agent (tdd-guide):
# TDD Oturumu: Piyasa Likidite Skoru Hesaplayıcı

## Adım 1: Interface Tanımla (SCAFFOLD)

```typescript
// lib/liquidity.ts
export interface MarketData {
  totalVolume: number
  bidAskSpread: number
  activeTraders: number
  lastTradeTime: Date
}

export function calculateLiquidityScore(market: MarketData): number {
  // TODO: Uygulama
  throw new Error('Not implemented')
}

Adım 2: Başarısız Test Yaz (RED)

// lib/liquidity.test.ts
import { calculateLiquidityScore } from './liquidity'

describe('calculateLiquidityScore', () => {
  it('likit piyasa için yüksek skor döndürmeli', () => {
    const market = {
      totalVolume: 100000,
      bidAskSpread: 0.01,
      activeTraders: 500,
      lastTradeTime: new Date()
    }

    const score = calculateLiquidityScore(market)

    expect(score).toBeGreaterThan(80)
    expect(score).toBeLessThanOrEqual(100)
  })

  it('az likit piyasa için düşük skor döndürmeli', () => {
    const market = {
      totalVolume: 100,
      bidAskSpread: 0.5,
      activeTraders: 2,
      lastTradeTime: new Date(Date.now() - 86400000) // 1 gün önce
    }

    const score = calculateLiquidityScore(market)

    expect(score).toBeLessThan(30)
    expect(score).toBeGreaterThanOrEqual(0)
  })

  it('edge case\'i idare etmeli: sıfır hacim', () => {
    const market = {
      totalVolume: 0,
      bidAskSpread: 0,
      activeTraders: 0,
      lastTradeTime: new Date()
    }

    const score = calculateLiquidityScore(market)

    expect(score).toBe(0)
  })
})

Adım 3: Testleri Çalıştır - Başarısızlığı Doğrula

npm test lib/liquidity.test.ts

FAIL lib/liquidity.test.ts
  ✕ should return high score for liquid market (2 ms)
    Error: Not implemented

1 test failed, 0 passed

✅ Testler beklendiği gibi başarısız. Uygulamaya hazır.

Adım 4: Minimal Kod Uygula (GREEN)

// lib/liquidity.ts
export function calculateLiquidityScore(market: MarketData): number {
  // Sıfır hacim edge case'ini idare et
  if (market.totalVolume === 0) {
    return 0
  }

  // Bileşen skorlarını hesapla (0-100 ölçeği)
  const volumeScore = Math.min(market.totalVolume / 1000, 100)
  const spreadScore = Math.max(100 - (market.bidAskSpread * 1000), 0)
  const traderScore = Math.min(market.activeTraders / 10, 100)

  // Son aktivite bonusu
  const hoursSinceLastTrade = (Date.now() - market.lastTradeTime.getTime()) / (1000 * 60 * 60)
  const recencyScore = Math.max(100 - (hoursSinceLastTrade * 10), 0)

  // Ağırlıklı ortalama
  const score = (
    volumeScore * 0.4 +
    spreadScore * 0.3 +
    traderScore * 0.2 +
    recencyScore * 0.1
  )

  return Math.min(Math.max(score, 0), 100) // 0-100 arası sınırla
}

Adım 5: Testleri Çalıştır - Başarıyı Doğrula

npm test lib/liquidity.test.ts

PASS lib/liquidity.test.ts
  ✓ should return high score for liquid market (3 ms)
  ✓ should return low score for illiquid market (2 ms)
  ✓ should handle edge case: zero volume (1 ms)

3 tests passed

✅ Tüm testler geçiyor!

Adım 6: Refactor Et (IYILEŞTIR)

// lib/liquidity.ts - Sabitler ve daha iyi okunabilirlik ile refactor edildi
const WEIGHTS = {
  VOLUME: 0.4,
  SPREAD: 0.3,
  TRADERS: 0.2,
  RECENCY: 0.1,
} as const

const SCALE_FACTORS = {
  VOLUME: 1000,
  SPREAD: 1000,
  TRADERS: 10,
  RECENCY_PENALTY: 10,
} as const

function clamp(value: number, min: number, max: number): number {
  return Math.min(Math.max(value, min), max)
}

export function calculateLiquidityScore(market: MarketData): number {
  if (market.totalVolume === 0) return 0

  const volumeScore = Math.min(market.totalVolume / SCALE_FACTORS.VOLUME, 100)
  const spreadScore = clamp(100 - (market.bidAskSpread * SCALE_FACTORS.SPREAD), 0, 100)
  const traderScore = Math.min(market.activeTraders / SCALE_FACTORS.TRADERS, 100)

  const hoursSinceLastTrade = (Date.now() - market.lastTradeTime.getTime()) / (1000 * 60 * 60)
  const recencyScore = clamp(100 - (hoursSinceLastTrade * SCALE_FACTORS.RECENCY_PENALTY), 0, 100)

  const weightedScore =
    volumeScore * WEIGHTS.VOLUME +
    spreadScore * WEIGHTS.SPREAD +
    traderScore * WEIGHTS.TRADERS +
    recencyScore * WEIGHTS.RECENCY

  return clamp(weightedScore, 0, 100)
}

Adım 7: Testlerin Hala Geçtiğini Doğrula

npm test lib/liquidity.test.ts

PASS lib/liquidity.test.ts
  ✓ should return high score for liquid market (3 ms)
  ✓ should return low score for illiquid market (2 ms)
  ✓ should handle edge case: zero volume (1 ms)

3 tests passed

✅ Refactoring tamamlandı, testler hala geçiyor!

Adım 8: Kapsama Oranını Kontrol Et

npm test -- --coverage lib/liquidity.test.ts

File           | % Stmts | % Branch | % Funcs | % Lines
---------------|---------|----------|---------|--------
liquidity.ts   |   100   |   100    |   100   |   100

Coverage: 100% ✅ (Hedef: 80%)

✅ TDD oturumu tamamlandı!

## TDD En İyi Uygulamaları

**YAPIN:**
- ✅ Herhangi bir uygulamadan ÖNCE testi yazın
- ✅ Testleri çalıştırın ve uygulamadan önce başarısız olduklarını doğrulayın
- ✅ Testleri geçirmek için minimal kod yazın
- ✅ Testler yeşil olduktan sonra refactor edin
- ✅ Edge case'leri ve hata senaryolarını ekleyin
- ✅ %80+ kapsama hedefleyin (kritik kod için %100)

**YAPMAYIN:**
- ❌ Testlerden önce uygulama yazmayın
- ❌ Her değişiklikten sonra testleri çalıştırmayı atlamayın
- ❌ Aynı anda çok fazla kod yazmayın
- ❌ Başarısız testleri görmezden gelmeyin
- ❌ Uygulama detaylarını test etmeyin (davranışı test edin)
- ❌ Her şeyi mock'lamayın (integration testleri tercih edin)

## Dahil Edilecek Test Türleri

**Unit Tests** (Fonksiyon seviyesi):
- Happy path senaryoları
- Edge case'ler (boş, null, maksimum değerler)
- Hata koşulları
- Sınır değerleri

**Integration Tests** (Component seviyesi):
- API endpoint'leri
- Database operasyonları
- Dış servis çağrıları
- Hook'lu React componentleri

**E2E Tests** (`/e2e` komutunu kullanın):
- Kritik kullanıcı akışları
- Çok adımlı süreçler
- Full stack entegrasyon

## Kapsama Gereksinimleri

- **Minimum %80** tüm kod için
- **%100 gerekli**:
  - Finansal hesaplamalar
  - Kimlik doğrulama mantığı
  - Güvenlik açısından kritik kod
  - Temel iş mantığı

## Önemli Notlar

**ZORUNLU**: Testler uygulamadan ÖNCE yazılmalıdır. TDD döngüsü:

1. **RED** - Başarısız test yaz
2. **GREEN** - Geçmek için uygula
3. **REFACTOR** - Kodu iyileştir

RED aşamasını asla atlamayın. Testlerden önce asla kod yazmayın.

## Diğer Komutlarla Entegrasyon

- Ne inşa edileceğini anlamak için önce `/plan` kullanın
- Testlerle uygulamak için `/tdd` kullanın
- Build hataları oluşursa `/build-fix` kullanın
- Uygulamayı gözden geçirmek için `/code-review` kullanın
- Kapsama oranını doğrulamak için `/test-coverage` kullanın

## İlgili Agent'lar

Bu komut, ECC tarafından sağlanan `tdd-guide` agent'ını çağırır.

İlgili `tdd-workflow` skill'i de ECC ile birlikte gelir.

Manuel kurulumlar için, kaynak dosyalar şurada bulunur:
- `agents/tdd-guide.md`
- `skills/tdd-workflow/SKILL.md`