group :development, :test do
  gem 'rspec-rails' # Rails uygulamaları için
  # veya bağımsız Ruby projeleri için:
  # gem 'rspec'
end

bundle exec rspec --init

• describe: Genellikle test edilen sınıfı, modülü veya birimini tanımlamak için kullanılır. Bir nevi test paketinizin başlığıdır.
• context: Belirli bir durum veya koşul altında test edilecek davranışları gruplamak için kullanılır. `describe`'a benzer, ancak daha spesifik bir durumu belirtir.
• it: Her bir bireysel test senaryosunu veya beklenen davranışı tanımlar. İçine asıl test kodunuzu ve beklentilerinizi yazarsınız. 'It should do X' veya 'It returns Y when Z' gibi cümlelerle isimlendirilir.

# spec/calculator_spec.rb

class Calculator
  def add(a, b)
    a + b
  end

  def subtract(a, b)
    a - b
  end
end

describe Calculator do
  describe '#add' do
    context 'iki pozitif sayı toplandığında' do
      it 'doğru toplamı döndürmeli' do
        calc = Calculator.new
        expect(calc.add(2, 3)).to eq(5)
      end
    end

    context 'pozitif ve negatif sayı toplandığında' do
      it 'sayı doğrusu üzerinde doğru sonucu vermeli' do
        calc = Calculator.new
        expect(calc.add(5, -2)).to eq(3)
      end
    end
  end

  describe '#subtract' do
    it 'iki sayının farkını doğru hesaplamalı' do
      calc = Calculator.new
      expect(calc.subtract(10, 4)).to eq(6)
    end

    it 'negatif sonuçları doğru işlemeli' do
      calc = Calculator.new
      expect(calc.subtract(4, 10)).to eq(-6)
    end
  end
end

• Eşitlik: `eq` (değer eşitliği), `be` (nesne eşitliği/aynılığı)
  
  Kod:

  expect(5).to eq(5) # Değer eşitliği
  expect('hello').to be('hello') # Nesne referansı eşitliği (aynı nesne olmalı, genelde stringlerde fail eder)
  my_array = [1,2,3]
  expect(my_array).to be(my_array) # Bu doğru olur

• Doğruluk/Yanlışlık/Boşluk: `be_truthy`, `be_falsey`, `be_nil`, `be_empty`
  
  Kod:

  expect(true).to be_truthy
  expect(nil).to be_falsey # false veya nil için
  expect(nil).to be_nil
  expect([]).to be_empty

• Sınıf Tipi: `be_an_instance_of`, `be_kind_of`
  
  Kod:

  expect([]).to be_an_instance_of(Array) # Sadece Array sınıfı
  expect([]).to be_kind_of(Enumerable) # Enumerable modülünü de içerir

• Kapsama: `include`
  
  Kod:

  expect([1, 2, 3]).to include(2)
  expect('hello world').to include('world')

• Hata Yükseltme: `raise_error`
  
  Kod:

  it 'sıfıra bölme hatası vermeli' do
    expect { 10 / 0 }.to raise_error(ZeroDivisionError)
    expect { raise 'Bir hata oluştu' }.to raise_error('Bir hata oluştu')
  end

• Değer Değişimi: `change`
  
  Kod:

  it 'kullanıcı sayısının artması' do
    # Varsayalım User.count bir sınıf metodu olsun
    expect { User.create(name: 'Test') }.to change(User, :count).by(1)
  end

• Özel Durumlar: `match` (Regex), `start_with`, `end_with`
  
  Kod:

  expect('Ruby is fun').to match(/Ruby/)
  expect('Hello World').to start_with('Hello')
  expect('Hello World').to end_with('World')

• Negatif Beklentiler: Tüm matcher'ların `to_not` veya `not_to` versiyonları vardır.
  
  Kod:

  expect(5).to_not eq(6)
  expect([]).to_not include(1)

• let: Test içerisinde bir değişken tanımlamanızı sağlar. Değişken, yalnızca ilk çağrıldığında değerlendirilir ve sonraki çağrılarda önbelleğe alınmış değeri kullanır. Bu, testlerin bağımsızlığını korurken kod tekrarını azaltır.
  
  Kod:

  describe User do
    let(:user) { User.create(name: 'Test User', email: 'test@example.com') }
  
    it 'is valid with a name and email' do
      expect(user).to be_valid
    end
  
    it 'has the correct email' do
      expect(user.email).to eq('test@example.com')
    end
  end

• let!: `let`'ten farklı olarak, `let!` bloğu, her `it` bloğu başlamadan önce hemen değerlendirilir. Yan etkileri olan (veritabanına kayıt gibi) işlemler için kullanışlıdır.
  
  Kod:

  describe 'bir işlem' do
    let!(:record) { Record.create(status: 'pending') } # Her it bloğundan önce oluşturulur
  
    it 'status güncellenmeli' do
      record.update(status: 'completed')
      expect(record.status).to eq('completed')
    end
  end

• subject: Test edilen ana nesneyi tanımlamak için kullanılır. Varsayılan olarak, `describe` bloğuna verilen sınıfın yeni bir örneğini oluşturur, ancak manuel olarak da tanımlanabilir. Daha sonra testlerde nesneye atıfta bulunmak için doğrudan `subject` veya implicit olarak `it { is_expected.to ... }` syntax'ı kullanılabilir.
  
  Kod:

  describe Product do
    subject { Product.new(price: 100, stock: 5) }
  
    it 'has a valid price' do
      expect(subject.price).to be > 0
    end
  
    it { is_expected.to respond_to(:stock) } # subject'e implicit referans
  end

• beforeeach) veya `before`: Her bir `it` bloğundan önce çalışır. Her testin bağımsız olmasını sağlamak için idealdir (örneğin, her test öncesi veritabanını temizlemek).
• beforeall): Bir `describe` veya `context` bloğundaki tüm `it` blokları çalışmadan önce sadece bir kez çalışır. Genellikle, maliyetli kurulum işlemleri için kullanılır (örneğin, test veri setini bir kez hazırlama).
• aftereach) veya `after`: Her bir `it` bloğundan sonra çalışır. Test sonrası kaynakları temizlemek için idealdir.
• afterall): Bir `describe` veya `context` bloğundaki tüm `it` blokları çalıştıktan sonra sadece bir kez çalışır.

describe 'Veritabanı işlemleri' do
  before(:each) do
    # Her test öncesi veritabanını temizle
    DatabaseCleaner.clean
  end

  before(:all) do
    # Tüm testlerden önce bir kez çalışacak setup
    puts 'Tüm testler başlamadan önce setup yapılıyor.'
  end

  it 'kullanıcı oluşturulmalı' do
    User.create(name: 'Ahmet')
    expect(User.count).to eq(1)
  end

  it 'başka bir kullanıcı oluşturulmalı' do
    User.create(name: 'Ayşe')
    expect(User.count).to eq(1) # Her test öncesi temizlendiği için hala 1
  end

  after(:each) do
    puts 'Her test sonrası temizlik yapıldı.'
  end

  after(:all) do
    puts 'Tüm testler bittikten sonra temizlik yapılıyor.'
  end
end

# spec/support/shared_examples/a_valid_entity.rb

RSpec.shared_examples 'bir geçerli varlık' do
  it 'bir isme sahip olmalı' do
    expect(subject.name).to_not be_nil
  end

  it 'bir açıklama metnine sahip olabilir' do
    expect(subject).to respond_to(:description)
  end
end

# spec/user_spec.rb
describe User do
  let(:name) { 'John Doe' }
  subject { User.new(name: name) }

  it_behaves_like 'bir geçerli varlık'

  it 'bir e-posta adresi olmalı' do
    subject.email = 'john@example.com'
    expect(subject.email).to eq('john@example.com')
  end
end

# spec/product_spec.rb
describe Product do
  let(:name) { 'Laptop' }
  subject { Product.new(name: name) }

  it_behaves_like 'bir geçerli varlık'

  it 'bir fiyatı olmalı' do
    subject.price = 1200
    expect(subject.price).to eq(1200)
  end
end

• Stubbing: Bir nesnenin bir metoda çağrıldığında belirli bir değer döndürmesini sağlamaktır. Gerçek metod çağrısının gerçekleşmesini engeller ve belirlediğiniz değeri geri verir.
  
  Kod:

  describe PaymentProcessor do
    it 'ödeme başarılı olduğunda true dönmeli' do
      payment_gateway = double('PaymentGateway')
      allow(payment_gateway).to receive(:charge).and_return(true)
  
      processor = PaymentProcessor.new(payment_gateway)
      expect(processor.process_payment(100)).to be_truthy
    end
  end

• Mocking: Stubbing'e ek olarak, belirli bir metodun çağrılıp çağrılmadığını, kaç kez çağrıldığını veya hangi argümanlarla çağrıldığını doğrulamanızı sağlar. Bir objenin belirli bir etkileşime sahip olmasını beklediğiniz durumlarda kullanılır.
  
  Kod:

  describe Notifier do
    it 'kullanıcıya e-posta göndermeli' do
      user = double('User')
      expect(user).to receive(:send_email).with('Hoşgeldin mesajı')
  
      Notifier.send_welcome_email(user)
    end
  end

  
  `double` metodu, gerçek bir sınıf veya nesneye ihtiyaç duymadan, yalnızca belirli metodlara yanıt veren sahte nesneler oluşturmanızı sağlar. Bu, testlerinizi daha hızlı ve izole hale getirir.

• `bundle exec rspec`: Tüm testleri çalıştırır.
• `bundle exec rspec spec/models/user_spec.rb`: Belirli bir test dosyasını çalıştırır.
• `bundle exec rspec spec/models/user_spec.rb:15`: Belirli bir dosyadaki belirli bir satırdaki testi çalıştırır.
• `bundle exec rspec --format documentation` veya `rspec -f d`: Test sonuçlarını daha okunabilir, dokümantasyon benzeri bir formatta gösterir.
• `bundle exec rspec --tag focus`: Sadece `focus: true` etiketi ile işaretlenmiş testleri çalıştırır (geçici olarak belirli testlere odaklanmak için).
• `bundle exec rspec --fail-fast`: İlk hata tespit edildiğinde testi durdurur. Hızlı hata ayıklama için kullanışlıdır.

"Testleriniz ne kadar iyiyse, kodunuz o kadar güvenlidir."
- Robert C. Martin (Uncle Bob)

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

• Her test tek bir şeyi test etmeli (Single Responsibility Principle): Her `it` bloğu yalnızca bir davranışı doğrulamalıdır. Bu, bir test başarısız olduğunda sorunun ne olduğunu anlamayı kolaylaştırır.
• Hızlı testler: Test süitiniz hızlı çalışmalıdır. Yavaş testler, geliştiricileri testleri çalıştırmaktan vazgeçirebilir. Harici bağımlılıkları (veritabanı, ağ) mock/stub yaparak hızı artırın.
• Bağımsız testler: Bir testin sonucu, başka bir testin çalıştırılıp çalıştırılmamasına veya sırasına bağlı olmamalıdır. `beforeeach)` hook'larını ve `let` kullanımlarını bu prensibi desteklemek için kullanın.
• Anlaşılır test isimleri: `describe` ve `it` bloklarını, testin neyi test ettiğini açıkça anlatan isimlerle adlandırın. Bir iş paydaşının bile okuyup anlayabileceği seviyede olmalıdırlar.
• Veri hazırlığı ve temizliği: Testleriniz için gerekli olan veriyi doğru şekilde hazırlayın ve test bittikten sonra bu veriyi temizleyin. `FactoryBot` gibi kütüphaneler veri hazırlığını otomatikleştirmek için çok faydalıdır.
• Negatif senaryoları test edin: Sadece başarılı senaryoları değil, hata durumlarını, geçersiz girişleri ve beklenmedik durumları da test edin.
• Test kapsamı (Code Coverage): Kodunuzun ne kadarının testler tarafından kapsandığını ölçün. SimpleCov gibi gem'ler bu konuda size yardımcı olabilir. Ancak %100 kapsama körü körüne ulaşmak yerine, kritik iş mantığınızın iyi test edildiğinden emin olun.