• Hata Tespiti ve Önleme: Geliştirme sürecinin erken aşamalarında hataları yakalayarak, üretim ortamına ulaşmadan önce düzeltilmesini sağlar.
• Kod Kalitesi ve Refaktöring Güvenliği: Mevcut kodunuzu değiştirirken veya yeni özellikler eklerken, testler sayesinde mevcut işlevselliğin bozulmadığından emin olursunuz. Bu, cesurca refaktöring yapmanızı sağlar.
• Geriye Dönük Uyumluluk: Uygulamanızın farklı sürümleri arasında veya bağımlılık güncellemelerinde geriye dönük uyumluluğun korunmasına yardımcı olur.
• Dokümantasyon: İyi yazılmış testler, kodunuzun ne yapması gerektiğini açıkça gösteren canlı bir dokümantasyon görevi görür.
• Tasarım İyileştirmesi: Test yazma süreci, daha modüler, bağımsız ve test edilebilir kod yazmaya teşvik ederek yazılım tasarımınızı doğrudan iyileştirir.

gem 'rspec', '~> 3.0', group: :development, :test
# Eğer Ruby on Rails projeniz varsa, rspec-rails gem'ini kullanmanız daha uygun olacaktır:
# gem 'rspec-rails', '~> 6.0', group: :development, :test

bundle install

rspec --init

# spec/calculator_spec.rb

describe 'Calculator' do
  context 'when adding numbers' do
    it 'returns the sum of two positive integers' do
      calculator = Calculator.new
      expect(calculator.add(2, 3)).to eq(5)
    end

    it 'returns the sum even if one number is zero' do
      calculator = Calculator.new
      expect(calculator.add(5, 0)).to eq(5)
    end
  end

  context 'when dividing numbers' do
    it 'raises an error when dividing by zero' do
      calculator = Calculator.new
      expect { calculator.divide(10, 0) }.to raise_error(ArgumentError, 'Cannot divide by zero')
    end
  end
end

• `expect(value).to eq(expected_value)`: Değerlerin eşitliğini kontrol eder.
• `expect(value).not_to eq(unexpected_value)`: Değerlerin eşit olmadığını kontrol eder.
• `expect(array).to include(item)`: Bir dizinin belirli bir öğeyi içerip içermediğini kontrol eder.
• `expect(object).to be_nil`: Bir nesnenin `nil` olup olmadığını kontrol eder.
• `expect(number).to be > 10`: Sayısal karşılaştırmalar (`be <`, `be >=`, `be <=`).
• `expect(boolean).to be_truthy` / `be_falsey`: Doğruluk değerlerini kontrol eder.
• `expect { code_block }.to raise_error(ErrorClass)`: Bir kod bloğunun belirli bir hata fırlatıp fırlatmadığını kontrol eder.
• `expect(object).to respond_tomethod_name)`: Bir nesnenin belirli bir metoda sahip olup olmadığını kontrol eder.
• `expect(collection).to be_empty`: Bir koleksiyonun boş olup olmadığını kontrol eder.

• Stub: Bir nesnenin belirli bir mesajı aldığında önceden tanımlanmış bir değer döndürmesini sağlar. Stub'lar, gerçek nesnelerin davranışını taklit eder ancak çağrıları kaydetmezler. Örneğin, bir API çağrısı yerine sabit bir değer döndürmek için kullanılabilir.
  
  Kod:

  user = double('User')
  allow(user).to receive(:full_name).and_return('Jane Doe')
  
  # Gerçek bir veritabanı bağlantısı kurmak yerine, kullanıcının adını stublarız.
  expect(user.full_name).to eq('Jane Doe')

• Mock: Bir nesnenin belirli bir mesajı belirli bir şekilde alıp almadığını doğrular. Mock'lar, hem davranış taklidi yapar hem de çağrıları kontrol eder. Genellikle bir metot çağrısının gerçekleştiğini doğrulamak için kullanılır.
  
  Kod:

  order = double('Order')
  expect(order).to receive(:process_payment).with(amount: 100)
  
  # Bir senaryoda ödeme işleminin çağrıldığını doğrularız.
  order.process_payment(amount: 100)

• Spy: Bir nesnenin metotlarını otomatik olarak izler, böylece daha sonra bu metotların çağrılıp çağrılmadığını kontrol edebilirsiniz. `receive` yerine `have_received` kullanılarak doğrulanır. Spy'lar, stub'lar gibi davranır ancak çağrı geçmişini kaydederler.
  
  Kod:

  notifier = double('Notifier')
  allow(notifier).to receive(:send_email)
  
  # Bir e-posta gönderme işlemi çağrılır...
  notifier.send_email('admin@example.com', 'Welcome!')
  
  # Daha sonra, e-postanın gönderilip gönderilmediğini kontrol ederiz.
  expect(notifier).to have_received(:send_email).with('admin@example.com', 'Welcome!')

Test çiftlerini doğru kullanmak, testlerinizin hızlı, izole ve güvenilir olmasını sağlar, bağımlılıkları yönetmenize yardımcı olur.

Genişletmek için tıkla ...

• beforeeach) veya before do: Her `it` bloğundan önce çalışır. Test ortamını hazırlamak için kullanılır (örn: yeni bir nesne oluşturmak).
  
  Kod:

  describe 'BankAccount' do
    let(:account) { BankAccount.new(100) } # her test için yeni bir hesap oluşturur
    before(:each) do
      puts "Yeni bir test başlıyor... Mevcut bakiye: #\{account.balance\}"
    end
  
    it 'deposits money correctly' do
      account.deposit(50)
      expect(account.balance).to eq(150)
    end
  
    it 'withdraws money correctly' do
      account.withdraw(30)
      expect(account.balance).to eq(70)
    end
  end

• beforeall): Belirli bir `describe` veya `context` bloğundaki tüm `it` bloklarından sadece bir kez önce çalışır. Daha yavaş kaynakları (örn: veritabanı bağlantısı) tek seferlik hazırlamak için kullanılabilir, ancak testler arası bağımlılık oluşturma riskini taşır.
  
• aftereach) veya after do: Her `it` bloğundan sonra çalışır. Test ortamını temizlemek için kullanılır (örn: oluşturulan dosyaları silmek).
  
• afterall): Belirli bir `describe` veya `context` bloğundaki tüm `it` blokları bittikten sonra sadece bir kez çalışır.
  
• aroundeach) veya around do |test|: Bir `it` bloğunun etrafında çalışır. Testin başlangıcında ve sonunda belirli işlemler yapmak için kullanılır. Örneğin, bir veritabanı işlemi için transaction başlatıp bitirmek gibi.
  
  Kod:

  describe 'Database transaction' do
    around(:each) do |test|
      DB.transaction { test.run } # Testi bir veritabanı işlemi içinde çalıştır
    end
  
    it 'saves data' do
      # ... veritabanı kaydetme işlemleri ...
    end
  end

• Unit Testleri: Uygulamanın en küçük, bağımsız birimlerini (metotlar, sınıflar) izole bir şekilde test eder. Hızlıdır ve hatanın nerede olduğunu kolayca belirlemeye yardımcı olur. RSpec genellikle unit testleri için çok uygundur.
  
• Integration Testleri: Birden fazla birimin veya bileşenin birlikte nasıl çalıştığını test eder. Örneğin, bir veritabanı katmanının bir modelle veya bir API istemcisinin bir servis katmanıyla etkileşimini test etmek. Bunlar unit testlerinden daha yavaş olabilir, çünkü gerçek bağımlılıkları kullanırlar.
  
• Feature (Acceptance/End-to-End) Testleri: Uygulamanın tam kullanıcı akışını, genellikle web tarayıcısı üzerinden taklit ederek test eder. Capybara gibi kütüphanelerle birlikte RSpec kullanılarak yazılabilir. Bu testler en yavaş olanlardır ancak uygulamanın tamamının beklendiği gibi çalıştığından emin olmanın en kapsamlı yoludur. Kullanıcı hikayelerini veya iş gereksinimlerini doğrudan doğrular.

• Hızlı Testler Yazın: Test süitenizin tamamının mümkün olduğunca hızlı çalışmasını sağlayın. Yavaş testler, geliştiricilerin testleri daha az çalıştırmasına ve dolayısıyla hataları daha geç fark etmesine neden olur.
  
• Bağımsız Testler (Independent Tests): Her testin diğer testlerden bağımsız olduğundan emin olun. Bir testin sonucunun başka bir testin sonucunu etkilememesi gerekir. `beforeeach)` ve `let` gibi yapılar bu bağımsızlığı sağlamak için idealdir.
  
• Tek Sorumluluk Prensibi (Single Responsibility Principle - SRP): Testleriniz de kodunuz gibi tek bir sorumluluğa sahip olmalıdır. Her `it` bloğu tek bir davranış beklentisini doğrulamalıdır.
  
• Anlamlı Hata Mesajları: Beklentilerinize açıklayıcı mesajlar ekleyerek, bir test başarısız olduğunda neyin yanlış gittiğini kolayca anlamanızı sağlayın. `expect(value).to eq(expected_value), 'Hatalı toplama işlemi!'`
  
• Sadece Gerekli Olanı Test Edin: Tüm getter/setter metotları veya basit delegate'ler gibi bariz şeyleri test etmek yerine, iş mantığı içeren karmaşık davranışlara odaklanın.
  
• Testleri Okunabilir Tutun: `describe` ve `context` açıklamalarınızın net ve anlaşılır olduğundan emin olun. Kod gibi, testler de okunabilirlik açısından önemlidir.
  
• Fixtures/Factories Kullanın: Karmaşık model nesneleri oluşturmak için `FactoryBot` gibi kütüphaneleri kullanarak test verilerini kolayca yönetin. Bu, test kurulumunu basitleştirir ve DRY prensibine yardımcı olur.