rspec-coder

RSpec Coder

Core Philosophy

• AAA Pattern: Arrange-Act-Assert structure for clarity
• Behavior over Implementation: Test what code does, not how
• Isolation: Tests should be independent
• Descriptive Names: Blocks should clearly explain behavior
• Coverage: Test happy paths AND edge cases
• Fast Tests: Minimize database operations
• Fixtures: Use fixtures for common data setup
• Shoulda Matchers: Use for validations and associations

Critical Conventions

❌ Don't Add require 'rails_helper'

RSpec imports via .rspec config. Adding manually is redundant.

# ✅ GOOD - no require needed
RSpec.describe User do
  # ...
end

❌ Don't Add Redundant Spec Type

RSpec infers type from file location automatically.

# ✅ GOOD - type inferred from spec/models/ location
RSpec.describe User do
  # ...
end

✅ Use Namespace WITHOUT Leading ::

# ✅ GOOD - no leading double colons
RSpec.describe DynamicsGp::ERPSynchronizer do
  # ...
end

Test Organization

File Structure

• spec/models/ - Model unit tests
• spec/services/ - Service object tests
• spec/controllers/ - Controller tests
• spec/requests/ - Request specs (API testing)
• spec/mailers/ - Mailer tests
• spec/jobs/ - Background job tests
• spec/fixtures/ - Test data
• spec/support/ - Helper modules and shared examples
• spec/rails_helper.rb - Rails-specific configuration

Using describe and context

Block	Purpose	Example
describe	Groups by method/class	describe "#process"
context	Groups by condition	context "when user is admin"

RSpec.describe OrderProcessor do
  describe "#process" do
    context "with valid payment" do
      # success tests
    end

    context "with invalid payment" do
      # failure tests
    end
  end
end

Subject and Let

See references/patterns.md for detailed examples.

Pattern	Use Case
subject(:name) { ... }	Primary object/method under test
let(:name) { ... }	Lazy-evaluated, memoized data
let!(:name) { ... }	Eager evaluation (before each test)

RSpec.describe User do
  describe "#full_name" do
    subject(:full_name) { user.full_name }
    let(:user) { users(:alice) }

    it { is_expected.to eq("Alice Smith") }
  end
end

Fixtures

See references/patterns.md for detailed examples.

# spec/fixtures/users.yml
alice:
  name: Alice Smith
  email: alice@example.com
  admin: false

RSpec.describe User do
  fixtures :users

  it "validates email" do
    expect(users(:alice)).to be_valid
  end
end

Mocking and Stubbing

See references/patterns.md for detailed examples.

Method	Purpose
allow(obj).to receive(:method)	Stub return value
expect(obj).to receive(:method)	Verify call happens

# Stubbing external service
allow(PaymentGateway).to receive(:charge).and_return(true)

# Verifying method called
expect(UserMailer).to receive(:welcome_email).with(user)

Matchers Quick Reference

See references/matchers.md for complete reference.

Essential Matchers

# Equality
expect(value).to eq(expected)

# Truthiness
expect(obj).to be_valid
expect(obj).to be_truthy

# Change
expect { action }.to change { obj.status }.to("completed")
expect { action }.to change(Model, :count).by(1)

# Errors
expect { action }.to raise_error(SomeError)

# Collections
expect(array).to include(item)
expect(array).to be_empty

Shoulda Matchers

# Validations
it { is_expected.to validate_presence_of(:name) }
it { is_expected.to validate_uniqueness_of(:email) }

# Associations
it { is_expected.to have_many(:posts) }
it { is_expected.to belong_to(:account) }

AAA Pattern

Structure all tests as Arrange-Act-Assert:

describe "#process_refund" do
  subject(:process_refund) { processor.process_refund }

  let(:order) { orders(:completed_order) }
  let(:processor) { described_class.new(order) }

  it "updates order status" do
    process_refund  # Act
    expect(order.reload.status).to eq("refunded")  # Assert
  end

  it "credits user account" do
    expect { process_refund }  # Act
      .to change { order.user.reload.account_balance }  # Assert
      .by(order.total)
  end
end

Test Coverage Standards

What to Test

Type	Test For
Models	Validations, associations, scopes, callbacks, methods
Services	Happy path, sad path, edge cases, external integrations
Controllers	Status codes, response formats, auth, redirects
Jobs	Execution, retry logic, error handling, idempotency

Coverage Example

RSpec.describe User do
  fixtures :users

  describe "validations" do
    subject(:user) { users(:valid_user) }

    it { is_expected.to validate_presence_of(:name) }
    it { is_expected.to validate_presence_of(:email) }
    it { is_expected.to validate_uniqueness_of(:email).case_insensitive }
  end

  describe "associations" do
    it { is_expected.to have_many(:posts).dependent(:destroy) }
  end

  describe "#full_name" do
    subject(:full_name) { user.full_name }
    let(:user) { User.new(first_name: "Alice", last_name: "Smith") }

    it { is_expected.to eq("Alice Smith") }

    context "when last name is missing" do
      let(:user) { User.new(first_name: "Alice") }
      it { is_expected.to eq("Alice") }
    end
  end
end

Anti-Patterns

See references/anti-patterns.md for detailed examples.

Anti-Pattern	Why Bad
require 'rails_helper'	Redundant, loaded via .rspec
type: :model	Redundant, inferred from location
Leading :: in namespace	Violates RuboCop style
Empty test bodies	False confidence
Testing private methods	Couples to implementation
Not using fixtures	Slow tests
Not using shoulda	Verbose validation tests

Best Practices Checklist

Critical Conventions:

• NOT adding require 'rails_helper'
• NOT adding redundant spec type
• Using namespace WITHOUT leading ::

Test Organization:

• describe for methods/classes
• context for conditions
• Max 3 levels nesting

Test Data:

• Using fixtures (not factories)
• Using let for lazy data
• Using subject for method under test

Assertions:

• Shoulda matchers for validations
• Shoulda matchers for associations
• change matcher for state changes

Coverage:

• Happy path tested
• Sad path tested
• Edge cases covered

Quick Reference

# Minimal spec file
RSpec.describe User do
  fixtures :users

  describe "#full_name" do
    subject(:full_name) { user.full_name }
    let(:user) { users(:alice) }

    it { is_expected.to eq("Alice Smith") }
  end

  describe "validations" do
    subject(:user) { users(:alice) }

    it { is_expected.to validate_presence_of(:name) }
    it { is_expected.to have_many(:posts) }
  end
end