TDD Workflow Automation Rails Guide 2025

# Gemfile
group :development, :test do
  gem 'guard-minitest', require: false  # For Minitest (Rails default)
  gem 'terminal-notifier-guard'         # macOS desktop notifications
  gem 'listen', '~> 3.8'                # Efficient file watching
end

# Install and initialize Guard
bundle install
bundle exec guard init minitest

# Guardfile - JetThoughts Production Configuration
guard :minitest, spring: 'bin/rails test', all_on_start: false do
  # Models: Run model test + related controller/request tests
  watch(%r{^app/models/(.+)\.rb$}) do |m|
    tests = ["test/models/#{m[1]}_test.rb"]

    # Add controller tests if they reference this model
    controller = "test/controllers/#{m[1].pluralize}_controller_test.rb"
    tests << controller if File.exist?(controller)

    # Add request tests if they exist
    request = "test/requests/#{m[1].pluralize}_test.rb"
    tests << request if File.exist?(request)

    tests
  end

  # Controllers: Run controller + request + integration tests
  watch(%r{^app/controllers/(.+)_controller\.rb$}) do |m|
    tests = []
    tests << "test/controllers/#{m[1]}_controller_test.rb"
    tests << "test/requests/#{m[1]}_test.rb" if File.exist?("test/requests/#{m[1]}_test.rb")
    tests << "test/integration/#{m[1]}_integration_test.rb" if File.exist?("test/integration/#{m[1]}_integration_test.rb")
    tests.select { |t| File.exist?(t) }
  end

  # Services/Jobs: Run service test + integration specs
  watch(%r{^app/services/(.+)\.rb$}) do |m|
    tests = ["test/services/#{m[1]}_test.rb"]
    integration = "test/integration/#{m[1]}_integration_test.rb"
    tests << integration if File.exist?(integration)
    tests.select { |t| File.exist?(t) }
  end

  # Views: Run view tests only (fast feedback)
  watch(%r{^app/views/(.+)/(.+)\.html\.erb$}) do |m|
    "test/views/#{m[1]}/#{m[2]}_test.rb" if File.exist?("test/views/#{m[1]}/#{m[2]}_test.rb")
  end

  # Test files: Run the test that changed
  watch(%r{^test/(.+)_test\.rb$})

  # Configuration changes: Run related test suite
  watch(%r{^config/routes\.rb$}) { 'test/controllers' }
  watch(%r{^config/initializers/}) { 'test' }
  watch('test/test_helper.rb') { 'test' }
end

# Start Guard with automated test running
bundle exec guard

# Guard interactive commands (within Guard shell):
all      # Run all tests
reload   # Reload Guardfile configuration
pause    # Pause file watching (useful during git operations)
resume   # Resume file watching
quit     # Exit Guard

bin/rails test test/models/user_test.rb
# Rails boots: 3-5 seconds
# Test runs: 0.2 seconds
# Total: 3.2-5.2 seconds

# First run (with Spring)
bin/rails test test/models/user_test.rb
# Rails boots: 3-5 seconds (one-time cost)
# Test runs: 0.2 seconds
# Total: 3.2-5.2 seconds

# Subsequent runs (Spring cached)
bin/rails test test/models/user_test.rb
# Rails already loaded: 0 seconds
# Test runs: 0.2 seconds
# Total: 0.2 seconds (15-25x faster!)

# config/spring.rb
require 'spring/watcher/listen'

# Application root for Spring management
Spring.application_root = Rails.root

# Use Listen gem for efficient file watching
Spring.watcher = Spring::Watcher::Listen

# Files that trigger Spring restart when changed
Spring.watch(
  ".ruby-version",     # Ruby version changes
  ".rbenv-vars",       # Environment variable changes
  "tmp/restart.txt",   # Manual restart trigger
  "tmp/caching-dev.txt", # Caching configuration
  "Gemfile.lock"       # Dependency changes
)

# Post-fork optimizations
Spring.after_fork do
  # Reset database connections (avoid connection pool exhaustion)
  if defined?(ActiveRecord::Base)
    ActiveRecord::Base.establish_connection
  end

  # Clear application cache (avoid stale data in tests)
  Rails.cache.clear if defined?(Rails.cache)

  # Preload FactoryBot factories for faster test execution
  FactoryBot.find_definitions if defined?(FactoryBot)
end

# .git/hooks/post-merge (runs after git pull)
#!/bin/bash
# Restart Spring after pulling changes
spring stop

# Make executable
chmod +x .git/hooks/post-merge

# .git/hooks/post-checkout (runs after branch switching)
#!/bin/bash
# Restart Spring when switching branches
spring stop

chmod +x .git/hooks/post-checkout

# Check Spring status
spring status

# Stop Spring (triggers restart on next test run)
spring stop

# Spring-aware test execution (automatically uses preloaded Rails)
bin/rails test test/models/user_test.rb

# Verify Spring is being used
spring binstub --all  # Generates Spring-aware binstubs

# Add to crontab (runs at 9 AM daily)
0 9 * * * cd /path/to/rails/app && spring stop

# 1,500 tests running sequentially
bin/rails test
# Execution: 28 minutes (one test after another)

# Gemfile
group :development, :test do
  gem 'parallel_tests'
end

bundle install

# Create isolated test databases (one per core)
bundle exec rake parallel:setup

# Run tests across 4 cores
bundle exec rake parallel:test

# test/test_helper.rb
ENV['RAILS_ENV'] ||= 'test'
require_relative '../config/environment'
require 'rails/test_help'

class ActiveSupport::TestCase
  # Use transactional fixtures (faster than database truncation)
  fixtures :all

  # Parallel test database isolation
  if ENV['TEST_ENV_NUMBER']
    # Each parallel process gets isolated database
    # TEST_ENV_NUMBER is set by parallel_tests gem (e.g., "", "2", "3", "4")
    database_suffix = ENV['TEST_ENV_NUMBER']

    # Configure ActiveRecord for parallel execution
    parallelize(workers: :number_of_processors) if respond_to?(:parallelize)

    # Clean database state (preserve schema_migrations for Rails migration tracking)
    parallelize_setup do |worker|
      # Rails creates isolated test databases per worker via parallel:create parallel:prepare
      # Only truncate data tables, exclude schema_migrations to preserve migration state
      tables_to_truncate = ActiveRecord::Base.connection.tables - ['schema_migrations']
      tables_to_truncate.each do |table|
        ActiveRecord::Base.connection.execute("TRUNCATE TABLE #{table} RESTART IDENTITY CASCADE")
      end
    end

    parallelize_teardown do |worker|
      # Cleanup after parallel worker completes
    end
  end
end

# .github/workflows/ci.yml
name: Rails Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: postgres
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

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

      - name: Setup parallel test databases
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
        run: |
          bundle exec rake parallel:create
          bundle exec rake parallel:prepare

      - name: Run tests in parallel
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
        run: bundle exec rake parallel:test

      - name: Upload test results
        if: failure()
        uses: actions/upload-artifact@v3
        with:
          name: test-results
          path: test/reports/

# Run single test by line number
bin/rails test test/models/user_test.rb:23

# Run tests matching name pattern
bin/rails test test/models/user_test.rb --name /validation/

# Run failed tests from previous run
bin/rails test --fail-fast  # Stops at first failure

# Guardfile - Focus mode integration
guard :minitest, spring: 'bin/rails test', all_on_start: false do
  # Check if file has focused tests (name: /.focus/)
  watch(%r{^test/(.+)_test\.rb$}) do |m|
    test_file = m[0]

    # Read test file and check for focused tests
    if File.read(test_file).match?(/def test_.*_focus/)
      # Run only focused tests
      "#{test_file} --name /focus/"
    else
      # Run entire test file
      test_file
    end
  end

  # Existing watch patterns...
end

# Run tests and save results
bin/rails test --defer-output

# Re-run only failed tests from previous run
bin/rails test --fail-fast --defer-output

Developer: "All tests pass locally" ✅
CI Pipeline: "Tests failed" ❌
Developer: "But it works on my machine!"

# .github/workflows/ci.yml - Production CI Configuration
name: Rails TDD Workflow

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 20

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

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

    steps:
      - uses: actions/checkout@v4

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

      - name: Install system dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y libpq-dev

      - name: Setup test databases (parallel)
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
          DATABASE_URL: postgres://postgres:postgres@localhost:5432/app_test
        run: |
          bundle exec rake parallel:create
          bundle exec rake parallel:prepare

      - name: Run tests in parallel (matches local workflow)
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
          DATABASE_URL: postgres://postgres:postgres@localhost:5432/app_test
          REDIS_URL: redis://localhost:6379/0
        run: bundle exec rake parallel:test

      - name: Upload test coverage
        if: always()
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/coverage.json
          fail_ci_if_error: false

      - name: Upload test failure screenshots
        if: failure()
        uses: actions/upload-artifact@v3
        with:
          name: test-failure-screenshots
          path: tmp/screenshots/
          retention-days: 7

# Exactly what CI runs
RAILS_ENV=test PARALLEL_TEST_PROCESSORS=4 bundle exec rake parallel:test

# .git/hooks/pre-commit
#!/bin/bash

echo "Running CI-parity validation..."

# Run exactly what CI runs (subset for speed)
RAILS_ENV=test bundle exec rake parallel:test

if [ $? -ne 0 ]; then
  echo "❌ Tests failed (same command CI will run)"
  echo "Fix tests before committing"
  exit 1
fi

echo "✅ CI-parity validation passed"

# ❌ FORBIDDEN: Testing implementation details
class UserTest < ActiveSupport::TestCase
  def test_has_name_attribute
    user = User.new
    assert user.respond_to?(:name)  # Tests method existence, not behavior
  end

  def test_uses_bcrypt_for_password
    user = User.new(password: "secret")
    assert_instance_of BCrypt::Password, user.encrypted_password  # Tests internal library choice
  end
end

# ✅ CORRECT: Testing behavior and outcomes
class UserTest < ActiveSupport::TestCase
  def test_user_creation_with_valid_attributes
    user = User.new(name: "John Doe", email: "john@example.com")

    assert user.valid?, "User with valid attributes should be valid"
    assert_equal "John Doe", user.name, "User name should be persisted"
    assert_equal "john@example.com", user.email, "User email should be persisted"
  end

  def test_user_authentication_with_correct_password
    user = User.create!(name: "John", email: "john@example.com", password: "secure123")

    # Test behavior: authentication succeeds with correct password
    assert user.authenticate("secure123"), "User should authenticate with correct password"
  end

  def test_user_authentication_fails_with_incorrect_password
    user = User.create!(name: "John", email: "john@example.com", password: "secure123")

    # Test behavior: authentication fails with wrong password
    refute user.authenticate("wrong"), "User should not authenticate with incorrect password"
  end
end

# ❌ FORBIDDEN: Existence testing
class OrderTest < ActiveSupport::TestCase
  def test_order_model_exists
    assert defined?(Order), "Order model should exist"
  end

  def test_order_has_total_method
    order = Order.new
    assert order.respond_to?(:total), "Order should have total method"
  end

  def test_order_has_items_association
    assert Order.method_defined?(:items), "Order should have items association"
  end
end

# ✅ CORRECT: Testing business behavior
class OrderTest < ActiveSupport::TestCase
  def test_order_total_includes_item_prices
    order = Order.new
    order.items << Item.new(price: 10.00)
    order.items << Item.new(price: 15.00)

    assert_equal 25.00, order.total, "Order total should sum item prices"
  end

  def test_order_total_includes_tax
    order = Order.new(tax_rate: 0.08)
    order.items << Item.new(price: 100.00)

    expected_total = 108.00  # 100 + (100 * 0.08)
    assert_equal expected_total, order.total, "Order total should include tax"
  end

  def test_order_applies_discount_code
    order = Order.new
    order.items << Item.new(price: 100.00)
    order.apply_discount_code("SAVE20")  # 20% discount

    assert_equal 80.00, order.total, "Order total should reflect 20% discount"
  end
end

# ❌ FORBIDDEN: Configuration testing
class ApplicationConfigTest < ActiveSupport::TestCase
  def test_database_adapter_is_postgresql
    assert_equal "postgresql", Rails.configuration.database_configuration["development"]["adapter"]
  end

  def test_mailer_delivery_method_is_smtp
    assert_equal :smtp, ActionMailer::Base.delivery_method
  end

  def test_time_zone_is_eastern
    assert_equal "Eastern Time (US & Canada)", Rails.application.config.time_zone
  end
end

# ✅ CORRECT: Testing configuration outcomes
class ApplicationIntegrationTest < ActiveSupport::TestCase
  def test_database_persists_records_correctly
    user = User.create!(name: "John", email: "john@example.com")

    # Reload from database to verify persistence
    persisted_user = User.find(user.id)
    assert_equal "John", persisted_user.name
    assert_equal "john@example.com", persisted_user.email
  end

  def test_mailer_sends_welcome_email
    user = User.create!(name: "John", email: "john@example.com")

    # Verify email was queued/delivered
    assert_emails 1 do
      UserMailer.welcome_email(user).deliver_now
    end

    # Verify email content
    email = ActionMailer::Base.deliveries.last
    assert_equal ["john@example.com"], email.to
    assert_match "Welcome", email.subject
  end

  def test_time_zone_conversion_displays_correctly
    # Create event at specific UTC time
    event = Event.create!(name: "Meeting", start_time: Time.utc(2025, 1, 15, 14, 0))

    # Verify time displays correctly in configured time zone
    assert_equal "9:00 AM EST", event.display_time
  end
end

# lib/tasks/test_quality.rake
namespace :test do
  desc "Validate test quality (detect test smells)"
  task :quality do
    test_files = Dir.glob("test/**/*_test.rb")
    violations = []

    test_files.each do |file|
      content = File.read(file)

      # Detect implementation testing
      if content.match?(/respond_to\?|method_defined\?|instance_of\?/)
        violations << "#{file}: Implementation testing detected (respond_to?, method_defined?)"
      end

      # Detect existence testing
      if content.match?(/assert defined\?\(|assert.*\.class\.name/)
        violations << "#{file}: Existence testing detected (defined?, class.name)"
      end

      # Detect configuration testing
      if content.match?(/Rails\.configuration\.|Rails\.application\.config\./)
        violations << "#{file}: Configuration testing detected (config values)"
      end
    end

    if violations.any?
      puts "❌ Test Quality Violations Detected:\n"
      violations.each { |v| puts "  - #{v}" }
      puts "\nRefactor to behavioral testing before committing."
      exit 1
    else
      puts "✅ All tests follow behavioral testing standards"
    end
  end
end

# .git/hooks/pre-commit
#!/bin/bash

bundle exec rake test:quality

if [ $? -ne 0 ]; then
  echo "Fix test quality issues before committing"
  exit 1
fi

class DiscountCalculatorTest < ActiveSupport::TestCase
  def test_premium_user_gets_15_percent_discount
    user = User.new(subscription: "premium")
    calculator = DiscountCalculator.new(user)

    discount = calculator.calculate(amount: 1000)

    assert_equal 150.0, discount, "Premium user should get 15% discount"
  end
end

class DiscountCalculator
  def initialize(user)
    @user = user
  end

  def calculate(amount:)
    # Shameless green: hardcode the exact value that makes test pass
    150.0
  end
end

# Second test case added
def test_regular_user_gets_10_percent_discount
  user = User.new(subscription: "regular")
  calculator = DiscountCalculator.new(user)

  discount = calculator.calculate(amount: 500)

  assert_equal 50.0, discount, "Regular user should get 10% discount"
end

# Shameless green implementation (now with duplication)
class DiscountCalculator
  def initialize(user)
    @user = user
  end

  def calculate(amount:)
    if @user.subscription == "premium"
      150.0  # Hardcoded premium discount
    elsif @user.subscription == "regular"
      50.0   # Hardcoded regular discount
    end
  end
end

150.0 and 50.0 are alike (both hardcoded discounts)

premium: 150.0 for 1000 amount = 15%
regular: 50.0 for 500 amount = 10%

class DiscountCalculator
  def initialize(user)
    @user = user
  end

  def calculate(amount:)
    rate = discount_rate
    amount * rate
  end

  private

  def discount_rate
    if @user.subscription == "premium"
      0.15
    elsif @user.subscription == "regular"
      0.10
    end
  end
end

class DiscountCalculator
  DISCOUNT_RATES = {
    "premium" => 0.15,
    "regular" => 0.10,
    "enterprise" => 0.20
  }.freeze

  def initialize(user)
    @user = user
  end

  def calculate(amount:)
    amount * discount_rate
  end

  private

  def discount_rate
    DISCOUNT_RATES.fetch(@user.subscription, 0.0)
  end
end

RED → GREEN → COMMIT → REFACTOR (flocking step 1) → COMMIT →
REFACTOR (flocking step 2) → COMMIT → INTEGRATE

commit 1: Add test for premium user discount
commit 2: Hardcode premium discount (shameless green)
commit 3: Add test for regular user discount
commit 4: Hardcode regular discount
commit 5: Extract discount_rate method (flocking rule 3)
commit 6: Replace hardcoded values with calculation (flocking)
commit 7: Add test for enterprise user discount
commit 8: Extract DISCOUNT_RATES constant (flocking convergence)
commit 9: Add default discount for unknown subscription types

# Gemfile - Add automation stack
group :development, :test do
  gem 'guard-minitest', require: false
  gem 'spring'
  gem 'parallel_tests'
  gem 'listen', '~> 3.8'
  gem 'terminal-notifier-guard'  # macOS notifications
end

bundle install

bundle exec guard init minitest

# Check Spring status
bundle exec spring status

# Generate Spring binstubs for faster execution
bundle exec spring binstub --all

# Create isolated databases for parallel execution
bundle exec rake parallel:create

# Load schema into all test databases
bundle exec rake parallel:prepare

# Guardfile - JetThoughts Production Configuration
guard :minitest, spring: 'bin/rails test', all_on_start: false do
  # Models: Run model test + related controller/request tests
  watch(%r{^app/models/(.+)\.rb$}) do |m|
    tests = ["test/models/#{m[1]}_test.rb"]

    controller = "test/controllers/#{m[1].pluralize}_controller_test.rb"
    tests << controller if File.exist?(controller)

    request = "test/requests/#{m[1].pluralize}_test.rb"
    tests << request if File.exist?(request)

    tests.select { |t| File.exist?(t) }
  end

  # Controllers: Run controller + request tests
  watch(%r{^app/controllers/(.+)_controller\.rb$}) do |m|
    tests = []
    tests << "test/controllers/#{m[1]}_controller_test.rb"
    tests << "test/requests/#{m[1]}_test.rb" if File.exist?("test/requests/#{m[1]}_test.rb")
    tests.select { |t| File.exist?(t) }
  end

  # Services: Run service test + integration
  watch(%r{^app/services/(.+)\.rb$}) do |m|
    tests = ["test/services/#{m[1]}_test.rb"]
    integration = "test/integration/#{m[1]}_integration_test.rb"
    tests << integration if File.exist?(integration)
    tests.select { |t| File.exist?(t) }
  end

  # Test files: Run changed test
  watch(%r{^test/(.+)_test\.rb$})

  # Configuration: Run related tests
  watch(%r{^config/routes\.rb$}) { 'test/controllers' }
  watch('test/test_helper.rb') { 'test' }
end

# Start Guard
bundle exec guard

# In separate terminal, modify a model file
touch app/models/user.rb

# Verify Guard automatically runs user_test.rb

# config/spring.rb
require 'spring/watcher/listen'

Spring.application_root = Rails.root
Spring.watcher = Spring::Watcher::Listen

Spring.watch(
  ".ruby-version",
  ".rbenv-vars",
  "tmp/restart.txt",
  "tmp/caching-dev.txt",
  "Gemfile.lock"
)

Spring.after_fork do
  if defined?(ActiveRecord::Base)
    ActiveRecord::Base.establish_connection
  end

  Rails.cache.clear if defined?(Rails.cache)

  FactoryBot.find_definitions if defined?(FactoryBot)
end

# .git/hooks/post-merge
#!/bin/bash
spring stop

# Make executable
chmod +x .git/hooks/post-merge

# Copy for other git operations
cp .git/hooks/post-merge .git/hooks/post-checkout
chmod +x .git/hooks/post-checkout

# First run (boots Rails)
time bin/rails test test/models/user_test.rb

# Second run (Spring cached)
time bin/rails test test/models/user_test.rb
# Should be 3-5x faster

# Guardfile - Add notification configuration at top
notification :terminal_notifier,
  subtitle: "Minitest Results",
  activate: 'com.googlecode.iterm2' if `uname`.strip == 'Darwin'

# Existing guard configuration...

# Restart Guard to load notification config
bundle exec guard

# Modify test file to trigger notification
# You should see macOS notification with test results

# .github/workflows/ci.yml
name: Rails TDD Workflow

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 20

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

    steps:
      - uses: actions/checkout@v4

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

      - name: Setup parallel test databases
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
        run: |
          bundle exec rake parallel:create
          bundle exec rake parallel:prepare

      - name: Run tests in parallel
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
        run: bundle exec rake parallel:test

baseline_metrics:
  test_feedback_time: "Measure before/after (manual → automated)"
  daily_test_runs: "Count automated vs manual execution"
  developer_satisfaction: "1-10 rating before and after"
  bug_detection_speed: "Time from code write to bug discovery"

## Issue: Guard keeps running wrong tests

**Symptoms**: Changing `app/models/user.rb` runs unrelated tests

**Root Cause**: Guard watching pattern too broad

**Fix**:
1. Edit Guardfile
2. Change: `watch(%r{^app/models/(.+)\.rb$}) { 'test' }`
3. To: `watch(%r{^app/models/(.+)\.rb$}) { |m| "test/models/#{m[1]}_test.rb" }`
4. Restart Guard: `reload` in Guard console

**Prevention**: Review Guardfile patterns weekly

metrics_dashboard:
  test_suite_runtime: "Track trends over time"
  parallel_efficiency: "CPU utilization during test runs"
  ci_cd_duration: "Pipeline execution time"
  developer_velocity: "Story points per sprint"

# Too broad (runs unrelated tests)
watch(%r{^app/models/(.+)\.rb$}) { 'test' }

# Better (runs only related tests)
watch(%r{^app/models/(.+)\.rb$}) { |m| "test/models/#{m[1]}_test.rb" }

# .git/hooks/post-checkout (auto-restart on branch switching)
#!/bin/bash
spring stop

# Add to ~/.zshrc or ~/.bashrc
alias dev-start='cd ~/projects/myapp && bundle exec guard &'

# Profile slowest 10 tests
bin/rails test --profile 10

# Common slow test culprits:
# - Database operations (use factories wisely, minimize DB hits)
# - External API calls (use VCR or stubbing)
# - Full-stack system tests (minimize, prefer unit/integration)

### Before Automation
- Manual test execution: 10-15 times/day per developer
- Average wait time: 2-3 minutes per run
- Daily waiting: 20-45 minutes
- Context switching cost: 2-4 lost productive hours
- Effective coding time: 4-5 hours/day

### After Automation
- Automatic test execution: 50-80 times/day
- Average feedback time: <5 seconds
- Daily waiting: <5 minutes total
- Flow state preserved: No context switches
- Effective coding time: 6-7 hours/day

### Productivity Gain: 30-40% more productive development time

### Team Velocity Improvement (15-person team)
- Before: 8-12 deployments/week (cautious due to slow feedback)
- After: 50-75 deployments/week (confident continuous deployment)
- Impact: 5-7x deployment frequency increase

### Business Value: Features reach users 5-7x faster

### Time from Code Write to Bug Discovery
- Before: 2-4 hours (waiting for CI/CD, manual testing, code review)
- After: <1 minute (instant test feedback on file save)
- Impact: 120-240x faster bug detection

### Quality Impact: Bugs caught before commit, not after deployment

### Production Incidents (3-Month Rolling Average)
- Before automation: 12-15 bugs/month reaching production
- After automation: 4-6 bugs/month reaching production
- Reduction: 60% fewer production bugs

**Root Cause Analysis**: Faster feedback = developers fix bugs immediately rather than context-switching back hours/days later

### Code Coverage Over 6 Months
- Month 0 (baseline): 68% coverage
- Month 3: 78% coverage
- Month 6: 86% coverage
- Improvement: +18 percentage points

**Behavioral Change**: Instant feedback encourages developers to write tests (TDD becomes default, not exception)

### Engineering Engagement Survey Results
Question: "Rate your development workflow productivity" (1-10 scale)

- Before automation: 5.6/10 average (frustration with slow tests)
- After automation: 8.7/10 average (delight with instant feedback)
- Improvement: 55% satisfaction increase

**Retention Impact**: Exit interviews at 3 client companies cited testing workflow as reason to stay

### Story Points Completed Per Sprint (2-week sprints)
- Before: 42 points average (team velocity)
- After: 61 points average (sustained over 6 months)
- Impact: 45% velocity increase

**Planning Impact**: Product roadmap accelerated by 6-9 months with same team size

### Developer Time Reclaimed (15-person team)
- Manual test waiting eliminated: 25 hours/month per developer
- Team total: 375 hours/month productivity reclaimed
- Annual value: 4,500 hours = $562,500 (at $125/hour blended rate)

**ROI**: $562,500 annual value from $0 tooling cost (open-source tools)
**Payback Period**: Immediate (no upfront investment required)

# config/environments/test.rb
Rails.application.configure do
  # Disable unnecessary features in test environment
  config.eager_load = false
  config.cache_classes = true  # Faster Spring startup

  # Disable email deliveries (huge time saver)
  config.action_mailer.perform_deliveries = false
  config.action_mailer.raise_delivery_errors = false

  # Skip background job processing
  config.active_job.queue_adapter = :test

  # Disable asset pipeline (no CSS/JS compilation in tests)
  config.assets.compile = false
  config.assets.digest = false
  config.assets.debug = false

  # Disable logging for faster test execution
  config.log_level = :warn
  config.active_record.verbose_query_logs = false
end

# test/test_helper.rb
ENV['RAILS_ENV'] ||= 'test'
require_relative '../config/environment'
require 'rails/test_help'

class ActiveSupport::TestCase
  # Use transactional fixtures (faster than database truncation)
  self.use_transactional_tests = true

  # Disable ActiveRecord logging in tests (noise reduction + performance)
  setup do
    ActiveRecord::Base.logger = nil
  end

  # Preload FactoryBot factories in Spring (faster factory creation)
  if defined?(FactoryBot)
    FactoryBot.find_definitions

    # Cache commonly used factories
    FactoryBot.define do
      to_create { |instance| instance.save(validate: false) }
    end
  end

  # Database connection pooling optimization
  parallelize_setup do |worker|
    ActiveRecord::Base.connection.disconnect!
  end

  parallelize_teardown do |worker|
    ActiveRecord::Base.connection.close
  end
end

# Guardfile - Progressive test execution
guard :minitest, spring: 'bin/rails test', all_on_start: false do
  watch(%r{^app/models/user\.rb$}) do
    # Stage 1: Run only User model test (fastest, 2-5 seconds)
    user_test = "test/models/user_test.rb"

    # Stage 2: If User test passes, run dependent tests
    dependent_tests = [
      "test/controllers/users_controller_test.rb",
      "test/requests/users_test.rb"
    ].select { |f| File.exist?(f) }

    # Execute progressively: model test first, then dependencies
    [user_test] + dependent_tests
  end
end

# .github/workflows/ci.yml
name: Rails TDD Workflow (Optimized)

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 15

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432
        options: --health-cmd pg_isready --health-interval 10s

    steps:
      - uses: actions/checkout@v4

      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: 3.2.0
          bundler-cache: true  # Cache gems automatically

      - name: Cache Spring application
        uses: actions/cache@v3
        with:
          path: tmp/cache/bootsnap
          key: ${{ runner.os }}-spring-${{ hashFiles('**/Gemfile.lock') }}
          restore-keys: |
            ${{ runner.os }}-spring-

      - name: Setup Spring
        run: |
          bundle exec spring binstub --all
          bundle exec spring server &

      - name: Setup parallel test databases
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
        run: |
          bundle exec rake parallel:create
          bundle exec rake parallel:prepare

      - name: Run tests with Spring (matching local workflow)
        env:
          RAILS_ENV: test
          PARALLEL_TEST_PROCESSORS: 4
        run: bundle exec spring rake parallel:test

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: test-results
          path: test/reports/