Ruby Testing with RSpec — Factories Mocks System Tests and TDD Explained

# Gemfile
group :development, :test do
  gem "rspec-rails"
  gem "factory_bot_rails"
  gem "faker"
  gem "shoulda-matchers"
end

group :test do
  gem "capybara"
  gem "selenium-webdriver"
  gem "database_cleaner-active_record"
end

bin/rails generate rspec:install
# Creates spec/spec_helper.rb and spec/rails_helper.rb

# spec/models/article_spec.rb
require "rails_helper"

RSpec.describe Article, type: :model do
  describe "validations" do
    it { should validate_presence_of(:title) }
    it { should validate_presence_of(:body) }
    it { should validate_length_of(:title).is_at_least(5) }
  end

  describe "associations" do
    it { should belong_to(:user) }
    it { should have_many(:comments).dependent(:destroy) }
  end

  describe "scopes" do
    let!(:published_article) { create(:article, :published) }
    let!(:draft_article) { create(:article, :draft) }

    it "returns only published articles" do
      expect(Article.published).to include(published_article)
      expect(Article.published).not_to include(draft_article)
    end
  end

  describe "#publish!" do
    let(:article) { create(:article, :draft) }

    it "sets published_at timestamp" do
      expect { article.publish! }
        .to change { article.published_at }
        .from(nil)
        .to(kind_of(Time))
    end
  end
end

# spec/factories/users.rb
FactoryBot.define do
  factory :user do
    name { Faker::Name.name }
    email { Faker::Internet.unique.email }
    password { "password123" }

    trait :admin do
      role { :admin }
    end

    trait :with_articles do
      after(:create) { |user| create_list(:article, 3, user: user) }
    end
  end
end

# spec/factories/articles.rb
FactoryBot.define do
  factory :article do
    title { Faker::Book.title }
    body { Faker::Lorem.paragraphs(number: 3).join("\n\n") }
    user

    trait :published do
      published_at { 1.day.ago }
    end

    trait :draft do
      published_at { nil }
    end
  end
end

# spec/requests/articles_spec.rb
require "rails_helper"

RSpec.describe "Articles", type: :request do
  let(:user) { create(:user) }
  let(:article) { create(:article, user: user) }

  describe "GET /articles" do
    it "returns a successful response" do
      get articles_path
      expect(response).to have_http_status(:ok)
    end

    it "lists published articles" do
      published = create(:article, :published, user: user)
      draft = create(:article, :draft, user: user)

      get articles_path
      expect(response.body).to include(published.title)
      expect(response.body).not_to include(draft.title)
    end
  end

  describe "POST /articles" do
    let(:valid_params) do
      { article: { title: "Test", body: "Content here" } }
    end

    context "when authenticated" do
      before { sign_in user }

      it "creates a new article" do
        expect {
          post articles_path, params: valid_params
        }.to change(Article, :count).by(1)
      end

      it "redirects to the article" do
        post articles_path, params: valid_params
        expect(response).to redirect_to(article_path(Article.last))
      end
    end

    context "when not authenticated" do
      it "redirects to login" do
        post articles_path, params: valid_params
        expect(response).to redirect_to(login_path)
      end
    end
  end
end

# spec/system/articles_spec.rb
require "rails_helper"

RSpec.describe "Articles", type: :system do
  let(:user) { create(:user) }

  before do
    driven_by(:selenium_chrome_headless)
    sign_in user
  end

  it "creates a new article" do
    visit new_article_path

    fill_in "Title", with: "My New Article"
    fill_in "Body", with: "This is the content of my article."
    click_button "Create Article"

    expect(page).to have_content("Article created!")
    expect(page).to have_content("My New Article")
  end

  it "displays validation errors" do
    visit new_article_path
    click_button "Create Article"

    expect(page).to have_content("Title can't be blank")
  end
end

describe "External service calls" do
  # Stub — replaces method with fixed return
  before do
    allow(PaymentGateway).to receive(:charge)
      .and_return(double(success?: true, transaction_id: "abc123"))
  end

  it "processes payment successfully" do
    order = create(:order)
    result = PaymentProcessor.charge(order)
    expect(result).to be_success
  end
end

describe "Email sending" do
  # Mock — expects method to be called
  it "sends welcome email" do
    expect(WelcomeMailer).to receive(:welcome_email).with(kind_of(User))
      .and_return(double(deliver_later: true))

    User.create!(name: "Alice", email: "alice@test.com")
  end

  # Message expectations
  it "sends exactly one email" do
    expect {
      post signup_path, params: { user: valid_attributes }
    }.to change { ActionMailer::Base.deliveries.count }.by(1)
  end
end

RSpec.describe Article, type: :model do
  # let — lazy-loaded, memoized
  let(:user) { create(:user) }
  let(:article) { create(:article, user: user) }

  # let! — eager-loaded
  let!(:existing_article) { create(:article, :published) }

  # subject — the object under test
  subject { build(:article) }

  # before — setup
  before do
    # Runs before each test
    create(:category, name: "Ruby")
  end

  # context — grouping by condition
  context "when published" do
    subject { build(:article, :published) }
    it { should be_published }
  end

  context "when draft" do
    subject { build(:article, :draft) }
    it { should_not be_published }
  end
end

# Equality
expect(actual).to eq(expected)
expect(actual).to_not eq(expected)
expect(actual).to be_nil

# Truthiness
expect(actual).to be_truthy
expect(actual).to be_falsy

# Change
expect { obj.save }.to change(Model, :count).by(1)
expect { obj.touch }.to change { obj.updated_at }

# Error
expect { obj.save! }.to raise_error(ActiveRecord::RecordInvalid)
expect { 1 / 0 }.to raise_error(ZeroDivisionError)

# Content
expect(response.body).to include("Welcome")
expect(page).to have_content("Article created!")
expect(page).to have_current_path(articles_path)

# Collection
expect(array).to include(element)
expect(array).to match_array(expected_array)
expect(array).to all(be > 0)

# Bad — tests how, not what
it "calls find_each" do
  expect(User).to receive(:find_each)
  Report.generate
end

# Good — tests the result
it "generates a report" do
  create_list(:user, 3, :active)
  report = Report.generate
  expect(report.user_count).to eq(3)
end

# Bad — creates records for every test
let(:user) { create(:user) }

# Good — use let! for records that must exist
let!(:users) { create_list(:user, 5) }

# Bad — tests multiple things
it "creates and updates and deletes" do
  # ...
end

# Good — one assertion per example
it "creates a record"
it "updates attributes"
it "deletes the record"

# Bad — mocks everything, tests nothing
allow(User).to receive(:find).and_return(user)
allow(Article).to receive(:new).and_return(article)

# Good — use real objects when practical
user = create(:user)
article = create(:article, user: user)

# spec/rails_helper.rb
config.use_transactional_fixtures = true
# Or use DatabaseCleaner for multi-database setups

# Setup RSpec
rails new testing_demo
cd testing_demo

# spec/models/calculator_spec.rb
require "rails_helper"

RSpec.describe "Calculator", type: :model do
  describe "basic arithmetic" do
    it "adds two numbers" do
      result = 2 + 3
      expect(result).to eq(5)
    end

    it "subtracts numbers" do
      expect(10 - 4).to eq(6)
    end
  end

  describe "edge cases" do
    it "handles zero" do
      expect(0 + 5).to eq(5)
    end

    it "handles negative numbers" do
      expect(-3 + 7).to eq(4)
    end
  end

  describe "with context" do
    subject { [1, 2, 3] }

    it { should include(2) }
    it { should_not include(5) }
    its(:size) { should eq(3) }
    its(:sum) { should eq(6) }
  end
end

bin/rails generate rspec:install
bundle exec rspec