Testing Rails Applications: From Zero to Confidence

        /\
       /  \     System Tests (few)
      /    \
     /______\
    /        \   Controller/Request Tests (some)
   /          \
  /____________\
 /              \ Model Tests (many)
/________________\

# Gemfile
group :development, :test do
  gem "rspec-rails", "~> 6.0"
  gem "factory_bot_rails"
  gem "faker"
end

bundle install
rails generate rspec:install

# spec/rails_helper.rb
require "spec_helper"
ENV["RAILS_ENV"] ||= "test"
require_relative "../config/environment"
require "rspec/rails"
require "factory_bot_rails"

RSpec.configure do |config|
  config.include FactoryBot::Syntax::Methods

  # Run each test in a database transaction
  config.use_transactional_fixtures = true

  # Run tests in random order
  config.order = :random

  # Automatically infer test type from file location
  config.infer_spec_type_from_file_location!
end

spec/
├── models/          # Model tests
├── controllers/     # Controller tests
├── requests/        # Request tests
├── system/          # System tests
├── mailers/         # Mailer tests
├── jobs/            # Job tests
├── factories/       # Factory definitions
├── support/         # Helpers and configuration
├── rails_helper.rb
└── spec_helper.rb

# spec/factories/users.rb
FactoryBot.define do
  factory :user do
    email { Faker::Internet.email }
    password { "password123" }
    password_confirmation { "password123" }
    name { Faker::Name.name }
    active { true }
    created_at { 1.day.ago }

    # Traits for variations
    trait :admin do
      admin { true }
    end

    trait :inactive do
      active { false }
    end

    trait :with_orders do
      after(:create) do |user|
        create_list(:order, 3, user: user)
      end
    end
  end
end

# Create a user
user = create(:user)

# Create with specific attributes
user = create(:user, email: "alice@example.com", name: "Alice")

# Use traits
admin = create(:user, :admin)
inactive_user = create(:user, :inactive)

# Build without saving (useful for validation tests)
user = build(:user, email: "invalid")  # Not saved to database

# Get a user without creating (for associations)
user = build_stubbed(:user)  # Simulated record, not saved

# Create multiple records
users = create_list(:user, 10)

# Create with associations
order = create(:order, user: user)

# spec/factories/orders.rb
FactoryBot.define do
  factory :order do
    user
    total_cents { 4999 }
    status { "pending" }
    created_at { Time.current }

    trait :completed do
      status { "completed" }
      completed_at { Time.current }
    end

    trait :with_items do
      after(:create) do |order|
        create_list(:order_item, 3, order: order)
      end
    end
  end
end

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

RSpec.describe User, type: :model do
  describe "validations" do
    it "is valid with valid attributes" do
      user = build(:user)
      expect(user).to be_valid
    end

    it "requires an email" do
      user = build(:user, email: nil)
      expect(user).not_to be_valid
      expect(user.errors[:email]).to include("can't be blank")
    end

    it "requires a unique email" do
      create(:user, email: "alice@example.com")
      duplicate = build(:user, email: "alice@example.com")
      expect(duplicate).not_to be_valid
      expect(duplicate.errors[:email]).to include("has already been taken")
    end

    it "requires a valid email format" do
      user = build(:user, email: "invalid")
      expect(user).not_to be_valid
      expect(user.errors[:email]).to include("is invalid")
    end

    it "requires a password" do
      user = build(:user, password: nil)
      expect(user).not_to be_valid
      expect(user.errors[:password]).to include("can't be blank")
    end

    it "requires a password of at least 6 characters" do
      user = build(:user, password: "12345")
      expect(user).not_to be_valid
      expect(user.errors[:password]).to include("is too short (minimum is 6 characters)")
    end
  end
end

RSpec.describe User, type: :model do
  describe "scopes" do
    describe ".active" do
      it "returns only active users" do
        active_user = create(:user, active: true)
        inactive_user = create(:user, active: false)

        expect(User.active).to include(active_user)
        expect(User.active).not_to include(inactive_user)
      end
    end

    describe ".admins" do
      it "returns only admin users" do
        admin = create(:user, :admin)
        regular = create(:user)

        expect(User.admins).to include(admin)
        expect(User.admins).not_to include(regular)
      end
    end
  end
end

RSpec.describe Order, type: :model do
  describe "#total" do
    it "sums the total of all items" do
      order = create(:order)
      create(:order_item, order: order, price_cents: 1000, quantity: 2)
      create(:order_item, order: order, price_cents: 500, quantity: 1)

      expect(order.total).to eq(2500)
    end

    it "returns 0 when there are no items" do
      order = create(:order)
      expect(order.total).to eq(0)
    end
  end

  describe "#paid?" do
    it "returns true when status is paid" do
      order = create(:order, status: "paid")
      expect(order).to be_paid
    end

    it "returns false when status is pending" do
      order = create(:order, status: "pending")
      expect(order).not_to be_paid
    end
  end
end

RSpec.describe User, type: :model do
  describe "#full_name" do
    it "combines first and last name" do
      user = build(:user, first_name: "Alice", last_name: "Smith")
      expect(user.full_name).to eq("Alice Smith")
    end

    it "returns first name when last name is missing" do
      user = build(:user, first_name: "Alice", last_name: nil)
      expect(user.full_name).to eq("Alice")
    end

    it "returns last name when first name is missing" do
      user = build(:user, first_name: nil, last_name: "Smith")
      expect(user.full_name).to eq("Smith")
    end

    it "returns 'Unknown' when both names are missing" do
      user = build(:user, first_name: nil, last_name: nil)
      expect(user.full_name).to eq("Unknown")
    end
  end
end

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

RSpec.describe "Users", type: :request do
  describe "GET /users" do
    it "returns a list of users" do
      create_list(:user, 3)

      get users_path

      expect(response).to have_http_status(:ok)
      expect(JSON.parse(response.body).size).to eq(3)
    end
  end

  describe "POST /users" do
    let(:valid_params) do
      { user: { email: "alice@example.com", name: "Alice", password: "password123" } }
    end

    it "creates a user" do
      expect {
        post users_path, params: valid_params
      }.to change(User, :count).by(1)
    end

    it "returns the created user" do
      post users_path, params: valid_params

      expect(response).to have_http_status(:created)
      expect(JSON.parse(response.body)["email"]).to eq("alice@example.com")
    end

    it "returns errors when invalid" do
      post users_path, params: { user: { email: "", name: "" } }

      expect(response).to have_http_status(:unprocessable_entity)
      expect(JSON.parse(response.body)["errors"]).to be_present
    end
  end
end

RSpec.describe "Orders", type: :request do
  let(:user) { create(:user) }
  let(:headers) { { "Authorization" => "Bearer #{generate_token(user)}" } }

  describe "GET /orders" do
    it "returns orders for the current user" do
      create_list(:order, 3, user: user)
      other_user = create(:user)
      create_list(:order, 2, user: other_user)

      get orders_path, headers: headers

      expect(JSON.parse(response.body).size).to eq(3)
    end

    it "returns unauthorized when not logged in" do
      get orders_path

      expect(response).to have_http_status(:unauthorized)
    end
  end
end

RSpec.describe "Products", type: :request do
  describe "GET /products/:id" do
    let(:product) { create(:product, name: "Laptop", price: 999.99) }

    it "returns the product with correct attributes" do
      get product_path(product)

      json = JSON.parse(response.body)

      expect(json["name"]).to eq("Laptop")
      expect(json["price"]).to eq(999.99)
      expect(json["id"]).to eq(product.id)
    end

    it "does not include sensitive attributes" do
      get product_path(product)

      json = JSON.parse(response.body)
      expect(json).not_to have_key("cost_price")
      expect(json).not_to have_key("profit_margin")
    end
  end
end

RSpec.describe "Pages", type: :request do
  describe "GET /" do
    it "renders the home page" do
      get root_path

      expect(response).to have_http_status(:ok)
      expect(response.body).to include("Welcome")
    end

    it "renders the correct layout" do
      get root_path

      expect(response.body).to include('data-theme="dark"')
    end
  end
end

# spec/system/features_helper.rb
require "rails_helper"
require "capybara/rspec"

RSpec.configure do |config|
  config.include Capybara::DSL
end

# spec/rails_helper.rb
RSpec.configure do |config|
  config.before(:each, type: :system) do
    driven_by :rack_test  # Fast, no JavaScript
  end

  config.before(:each, :js, type: :system) do
    driven_by :selenium_chrome_headless  # JavaScript support
  end
end

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

RSpec.describe "Authentication", type: :system do
  let(:user) { create(:user, email: "alice@example.com", password: "password123") }

  scenario "user logs in successfully" do
    visit login_path

    fill_in "Email", with: user.email
    fill_in "Password", with: "password123"
    click_button "Log In"

    expect(page).to have_content("Welcome back, #{user.name}!")
    expect(page).to have_current_path(dashboard_path)
  end

  scenario "user sees error with invalid credentials" do
    visit login_path

    fill_in "Email", with: user.email
    fill_in "Password", with: "wrongpassword"
    click_button "Log In"

    expect(page).to have_content("Invalid email or password")
    expect(page).to have_current_path(login_path)
  end

  scenario "user logs out successfully" do
    login_as(user)

    visit dashboard_path
    click_button "Log Out"

    expect(page).to have_content("Logged out successfully")
    expect(page).to have_current_path(root_path)
  end
end

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

RSpec.describe "Order Flow", type: :system do
  let(:user) { create(:user) }
  let(:product) { create(:product, name: "Laptop", price: 999.99, stock: 5) }

  before do
    login_as(user)
  end

  scenario "user places an order" do
    visit product_path(product)

    click_button "Add to Cart"
    expect(page).to have_content("Item added to cart")

    visit cart_path
    expect(page).to have_content("Laptop")
    expect(page).to have_content("$999.99")

    click_button "Checkout"

    fill_in "Shipping Address", with: "123 Main St"
    fill_in "Card Number", with: "4242424242424242"
    fill_in "Expiry", with: "12/25"
    fill_in "CVC", with: "123"
    click_button "Place Order"

    expect(page).to have_content("Order placed successfully!")
    expect(page).to have_content("Order #")
    expect(page).to have_content("$999.99")

    # Check order was created
    order = Order.last
    expect(order.user).to eq(user)
    expect(order.total).to eq(999.99)
    expect(order.items.count).to eq(1)
  end

  scenario "user sees error when product is out of stock" do
    product.update(stock: 0)

    visit product_path(product)

    expect(page).to have_content("Out of Stock")
    expect(page).not_to have_button("Add to Cart")
  end
end

# spec/system/interactive_features_spec.rb
RSpec.describe "Interactive Features", type: :system, js: true do
  scenario "user adds comment without page refresh" do
    user = create(:user)
    post = create(:post)

    login_as(user)
    visit post_path(post)

    fill_in "Comment", with: "Great post!"
    click_button "Submit"

    # Wait for Turbo Stream to update the page
    expect(page).to have_content("Great post!")
    expect(page).to have_selector(".comment", count: 1)
  end

  scenario "user searches products in real-time" do
    create(:product, name: "Laptop")
    create(:product, name: "Mouse")
    create(:product, name: "Keyboard")

    visit products_path

    fill_in "Search", with: "Lap"

    # Wait for search results to update
    expect(page).to have_content("Laptop")
    expect(page).not_to have_content("Mouse")
    expect(page).not_to have_content("Keyboard")
  end
end

RSpec.describe "Dashboard", type: :system do
  scenario "user sees dashboard stats" do
    login_as(user)
    visit dashboard_path

    # Using Capybara matchers
    expect(page).to have_selector("h1", text: "Dashboard")
    expect(page).to have_selector(".stat", count: 4)
    expect(page).to have_selector(".stat .number", text: /\d+/)

    # Within a specific element
    within(".recent-orders") do
      expect(page).to have_selector("tr", count: 5)
      expect(page).to have_link("Order #123")
    end

    # Find specific element
    expect(page).to have_css('div[data-testid="welcome-message"]')
  end
end

# spec/mailers/user_mailer_spec.rb
require "rails_helper"

RSpec.describe UserMailer, type: :mailer do
  let(:user) { create(:user, name: "Alice", email: "alice@example.com") }
  let(:mail) { UserMailer.welcome_email(user) }

  describe "#welcome_email" do
    it "renders the subject" do
      expect(mail.subject).to eq("Welcome to MyApp, Alice!")
    end

    it "renders the receiver email" do
      expect(mail.to).to eq(["alice@example.com"])
    end

    it "renders the sender email" do
      expect(mail.from).to eq(["noreply@myapp.com"])
    end

    it "includes the user's name" do
      expect(mail.body.encoded).to include("Hello, Alice")
    end

    it "includes a link to the dashboard" do
      expect(mail.body.encoded).to include(dashboard_url)
    end

    it "has both HTML and plain text parts" do
      expect(mail.parts.length).to eq(2)
      expect(mail.parts.first.content_type).to include("text/html")
      expect(mail.parts.last.content_type).to include("text/plain")
    end
  end
end

RSpec.describe UserMailer, type: :mailer do
  describe "#password_reset" do
    let(:user) { create(:user) }
    let(:mail) { UserMailer.password_reset(user) }

    it "includes the password reset link" do
      expect(mail.body.encoded).to include(edit_password_reset_url(user.reset_token))
    end

    it "includes the reset token in the link" do
      expect(mail.body.encoded).to include(user.reset_token)
    end
  end
end

RSpec.describe InvoiceMailer, type: :mailer do
  let(:invoice) { create(:invoice, :with_pdf) }
  let(:mail) { InvoiceMailer.invoice_email(invoice.user, invoice) }

  it "attaches the PDF" do
    expect(mail.attachments.count).to eq(1)
    expect(mail.attachments.first.content_type).to include("application/pdf")
    expect(mail.attachments.first.filename).to eq("invoice_#{invoice.id}.pdf")
  end
end

# spec/jobs/welcome_email_job_spec.rb
require "rails_helper"

RSpec.describe WelcomeEmailJob, type: :job do
  let(:user) { create(:user) }

  it "enqueues the job" do
    expect {
      WelcomeEmailJob.perform_later(user.id)
    }.to have_enqueued_job(WelcomeEmailJob).with(user.id)
  end

  it "sends the email" do
    expect {
      WelcomeEmailJob.perform_now(user.id)
    }.to change(ActionMailer::Base.deliveries, :count).by(1)
  end
end

RSpec.describe ProcessOrderJob, type: :job do
  let(:order) { create(:order, status: "pending") }

  it "updates the order status" do
    expect {
      ProcessOrderJob.perform_now(order.id)
    }.to change { order.reload.status }.from("pending").to("processed")
  end

  it "handles missing order gracefully" do
    expect {
      ProcessOrderJob.perform_now(999999)
    }.not_to raise_error
  end
end

RSpec.describe Order, type: :model do
  describe "#total" do
    context "when order has no items" do
      it "returns 0" do
        order = create(:order)
        expect(order.total).to eq(0)
      end
    end

    context "when order has items" do
      it "returns the sum of item totals" do
        order = create(:order)
        create(:order_item, order: order, price_cents: 1000, quantity: 2)
        expect(order.total).to eq(2000)
      end
    end
  end
end

# spec/support/shared_examples.rb
RSpec.shared_examples "archivable" do
  it "can be archived" do
    expect(subject).to respond_to(:archive)
    expect(subject).to respond_to(:unarchive)
    expect(subject).to respond_to(:archived?)
  end

  it "sets archived_at when archived" do
    expect { subject.archive }.to change { subject.archived_at }.from(nil)
  end
end

# In tests
RSpec.describe User, type: :model do
  it_behaves_like "archivable"
end

RSpec.describe "Slow tests", :slow do
  # Tests that take longer to run
end

# Run only slow tests
rspec --tag slow

# Run everything except slow tests
rspec --tag ~slow

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: password
          POSTGRES_USER: railsuser
          POSTGRES_DB: myapp_test
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

      redis:
        image: redis:7
        ports:
          - 6379:6379
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

      - name: Set up Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: 3.2.0
          bundler-cache: true

      - name: Install dependencies
        run: bundle install

      - name: Setup database
        run: |
          bundle exec rails db:create
          bundle exec rails db:schema:load
        env:
          RAILS_ENV: test
          DATABASE_URL: postgresql://railsuser:password@localhost:5432/myapp_test

      - name: Run tests
        run: bundle exec rspec
        env:
          RAILS_ENV: test
          DATABASE_URL: postgresql://railsuser:password@localhost:5432/myapp_test
          REDIS_URL: redis://localhost:6379/0

# Use parallel testing
rails test:parallel

# Use clean database between tests
config.use_transactional_fixtures = true

# Mock external services
allow(Stripe).to receive(:charge).and_return(true)

# Use data attributes instead of text
it "shows the user name" do
  expect(page).to have_css('[data-testid="user-name"]', text: "Alice")
end

# Use finders that don't depend on UI text
within(".user-card") do
  expect(page).to have_content("Alice")
end

# Test error cases too
it "handles invalid data gracefully" do
  # ...
end

# Test edge cases
it "works with empty arrays" do
  # ...
end

# Test with real-world data
it "handles unicode characters" do
  # ...
end

# Clean database between tests
config.use_transactional_fixtures = true

# Clean up in after blocks
after(:each) do
  # Clean up created records
end

# Use factories that build new records each time

# Generate RSpec
rails generate rspec:install

# Create a factory
rails generate factory_bot:model user

# Write a test
# spec/models/user_spec.rb

# Run tests
bundle exec rspec

# Run specific tests
bundle exec rspec spec/models/user_spec.rb