Self-Hosted Ruby Testing Ecosystem: RSpec vs Minitest vs Capybara — TDD, BDD & Acceptance Testing Compared

1
2
3

gem install rspec
# In your project:
rspec --init

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# spec/calculator_spec.rb
require 'calculator'

RSpec.describe Calculator do
  describe '#add' do
    context 'with positive numbers' do
      it 'returns the sum' do
        calc = Calculator.new
        expect(calc.add(2, 3)).to eq(5)
      end
    end

    context 'with negative numbers' do
      it 'handles subtraction correctly' do
        calc = Calculator.new
        expect(calc.add(-2, -3)).to eq(-5)
      end
    end
  end
end

1

gem install minitest

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# test/calculator_test.rb
require 'minitest/autorun'
require 'calculator'

class CalculatorTest < Minitest::Test
  def test_add_positive_numbers
    calc = Calculator.new
    assert_equal 5, calc.add(2, 3)
  end

  def test_add_negative_numbers
    calc = Calculator.new
    assert_equal(-5, calc.add(-2, -3))
  end
end

1

gem install capybara rspec

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# spec/features/login_spec.rb
require 'capybara/rspec'

RSpec.feature 'User login', type: :feature do
  scenario 'successful login' do
    visit '/login'
    fill_in 'Email', with: 'user@example.com'
    fill_in 'Password', with: 'password123'
    click_button 'Sign In'

    expect(page).to have_content('Welcome back')
    expect(page).to have_current_path('/dashboard')
  end

  scenario 'failed login with wrong password' do
    visit '/login'
    fill_in 'Email', with: 'user@example.com'
    fill_in 'Password', with: 'wrongpassword'
    click_button 'Sign In'

    expect(page).to have_content('Invalid email or password')
  end
end

1
2
3
4
5
6
7
8

# Stub a method return value
allow(user).to receive(:name).and_return("Alice")

# Expect a method to be called
expect(mailer).to receive(:send_welcome_email).with(user).once

# Mock a class method
allow(HTTParty).to receive(:get).and_return(double(body: '{}', code: 200))

1
2
3
4
5
6
7
8

# Using Minitest::Mock
mock = Minitest::Mock.new
mock.expect(:name, "Alice")
mock.expect(:save, true)

user_service = UserService.new(mock)
user_service.process
mock.verify  # Ensures all expected methods were called

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

RSpec.feature 'Shopping cart', js: true do
  scenario 'adding items to cart' do
    visit '/products'
    first('.product-card').click_button('Add to Cart')
    
    within '#cart-badge' do
      expect(page).to have_content('1')
    end
    
    visit '/cart'
    expect(page).to have_css('.cart-item', count: 1)
  end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

version: "3.8"
services:
  test:
    image: ruby:3.3-alpine
    working_dir: /app
    environment:
      - RAILS_ENV=test
      - DATABASE_URL=postgres://test:test@test-db:5432/test
    volumes:
      - .:/app
      - bundle:/usr/local/bundle
    command: >
      sh -c "bundle install && bundle exec rspec"
    depends_on:
      test-db:
        condition: service_healthy

  test-db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=test
      - POSTGRES_PASSWORD=test
      - POSTGRES_DB=test
    tmpfs: /var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U test"]
      interval: 2s
      timeout: 3s
      retries: 5

volumes:
  bundle:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

       /      /Capybara\        ← Few: critical user flows
     /----------    /   RSpec or  \      ← More: API, service integration
   /   Minitest      /----------------- /    RSpec or       \   ← Many: unit tests, models, helpers
/     Minitest        ```

**Test Data Management**: Use `factory_bot` (with RSpec) or fixtures (with Minitest) rather than raw ActiveRecord calls in test setup. This keeps tests maintainable as your schema evolves.

**Parallel Execution**: Both RSpec (via `parallel_tests` gem) and Minitest (via `minitest-parallel_fork`) support parallel test execution, dramatically reducing suite runtime on multi-core machines.


## CI/CD Integration and Pipeline Optimization

Integrating your Ruby test suite into a self-hosted CI pipeline requires careful configuration for reliability and speed. Here are battle-tested patterns that work with Drone, Jenkins, GitLab CI, or GitHub Actions on self-hosted runners.

**Test Splitting for Parallel Builds**: For large test suites (10,000+ examples), splitting tests across parallel CI nodes dramatically reduces feedback time. The `knapsack_pro` gem uses historical timing data to distribute test files evenly across nodes, while `test-queue` uses a master-worker model for sub-second test distribution.

**Database Optimization for CI**: Use PostgreSQL's `fsync=off` and `full_page_writes=off` in CI test databases — these settings trade crash safety for 2-3x faster test performance, acceptable since CI databases are ephemeral. For even faster tests, mount the database data directory on `tmpfs` (RAM disk) to eliminate disk I/O entirely. MySQL users can achieve similar gains with `innodb_flush_log_at_trx_commit=0`.

**Flaky Test Management**: RSpec's `--order random` flag combined with `--seed` output helps reproduce intermittent failures. Use `rspec-retry` to automatically retry flaky examples, but track retry frequency — a test that retries more than 5% of the time should be investigated. Minitest users can achieve similar results with `minitest-retry`.

**Coverage Thresholds with SimpleCov**: Set minimum coverage thresholds in CI to prevent coverage regression. The `refuse_coverage_drop` setting ensures each CI run maintains or improves coverage, preventing new untested code from being merged. Configure `SimpleCov.minimum_coverage 90` and `SimpleCov.minimum_coverage_by_file 80` in your spec helper.

**Artifact Storage and Debugging**: Save Capybara screenshots and RSpec HTML reports as CI artifacts for debugging failures. Configure Capybara's `save_and_open_screenshot` to use a consistent directory mounted as a CI volume. The `rspec-html-formatter` gem produces searchable HTML reports perfect for CI artifact browsing.

**Test Environment Isolation**: Run each CI job in its own Docker network namespace to prevent port conflicts between parallel test suites. Use Docker Compose's `--project-name` flag with a unique CI job identifier to ensure isolated service instances.


## FAQ

### Should I use RSpec or Minitest?

If you prefer explicit Ruby code with minimal abstraction, use Minitest. If you value readable test output and nested organizational structure, use RSpec. Both are production-proven — GitHub uses Minitest, while Shopify and Airbnb use RSpec. There's no wrong choice.

### Can I use Capybara with Minitest?

Absolutely. Capybara works with any test framework. For Minitest, include `Capybara::Minitest::Assertions` or use `capybara/minitest`. The DSL (`visit`, `fill_in`, `click_button`) works the same regardless of the underlying test framework.

### Is RSpec slower than Minitest?

RSpec has slightly more overhead due to its DSL and matcher resolution, but the difference is typically 5-10% on realistic test suites. For most projects, the productivity gains from RSpec's output and organization outweigh the marginal speed difference.

### What about SimpleCov for code coverage?

SimpleCov works with both RSpec and Minitest. Add `require 'simplecov'` at the top of your `spec_helper.rb` or `test_helper.rb`, and SimpleCov will generate HTML coverage reports after your test run completes.

### Do I need Capybara if I use system tests in Rails?

Rails system tests use Capybara under the hood. If you use Rails' built-in `ApplicationSystemTestCase`, you're already using Capybara. The standalone Capybara gem is useful for non-Rails Rack applications or when you want more control over driver configuration.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "TechArticle",
  "headline": "Self-Hosted Ruby Testing Ecosystem: RSpec vs Minitest vs Capybara — TDD, BDD & Acceptance Testing Compared",
  "description": "Comprehensive comparison of Ruby testing frameworks RSpec, Minitest, and Capybara covering BDD vs TDD philosophy, mocking patterns, Docker CI setup, testing pyramid strategy, and production best practices.",
  "datePublished": "2026-07-06",
  "dateModified": "2026-07-06",
  "author": {
    "@type": "Organization",
    "name": "OpenSwap Guide"
  },
  "publisher": {
    "@type": "Organization",
    "name": "OpenSwap Guide",
    "logo": {
      "@type": "ImageObject",
      "url": "https://hopkdj.github.io/openswap-guide/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://hopkdj.github.io/openswap-guide/posts/2026-07-06-ruby-testing-frameworks-rspec-minitest-capybara/"
  }
}
</script>

---

**💰 想测试你的市场判断力？我用 [Polymarket](https://polymarket.com/?r=fc8a0) 做预测市场交易——这是全球最大的预测市场平台，从大选结果到技术监管时间线，什么都可以押注。和赌博不同，这是真正的信息市场：你懂的信息越多，胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册：**[Polymarket.com](https://polymarket.com/?r=fc8a0)