ralph: add bootsnap and spring for faster test loading

Investigated slow unit test load times (~20s to load, 1.7s to run).
Root causes: eager loading of ~1400 files, no caching, misconfigured spring.

Changes:
- Add bootsnap gem for require caching (30-50% speedup expected)
- Configure bootsnap in config/boot.rb
- Create config/spring.rb for proper Spring preloader setup
- Document findings in docs/internal/test_performance.md

Author: Gerg

.ralph/progress.md

@@ -4,8 +4,8 @@
 
 ## Summary
 
-- Iterations completed: 0
-- Current status: Initialized
+- Iterations completed: 1
+- Current status: Implementation complete, needs verification
 
 ## How This Works
 
@@ -18,3 +18,33 @@ This is how Ralph maintains continuity across iterations.
 
 ### 2026-01-22 14:41:38
 **Session 1 started** (model: opus-4.5)
+
+### 2026-01-22 (Iteration 1)
+**Completed:**
+- Analyzed test loading performance, identified root causes:
+  - Eager loading of ~1400 Ruby files on every test run
+  - No bootsnap caching
+  - Spring not properly configured
+  - Outdated Spork code still present
+- Created comprehensive documentation at `docs/internal/test_performance.md`
+- Added bootsnap to Gemfile and configured in `config/boot.rb`
+- Created `config/spring.rb` for proper Spring configuration
+
+**Changes made:**
+- `Gemfile`: Added bootsnap gem
+- `config/boot.rb`: Added bootsnap initialization
+- `config/spring.rb`: Created Spring configuration
+- `docs/internal/test_performance.md`: Created documentation
+- `RALPH_TASK.md`: Checked off criteria 1 and 2
+
+**Blocked:**
+- Cannot run tests to verify speedup - Ruby environment not properly set up (system Ruby 2.6.10 instead of required 3.2.10)
+- Need to run `bundle install` in proper Ruby environment, then test with:
+  ```
+  time bundle exec rspec spec/unit/actions/app_create_spec.rb
+  ```
+
+**Next steps:**
+- Install bundle in proper Ruby environment
+- Run test and measure improvement
+- Mark criterion 3 complete if successful

Gemfile

@@ -92,6 +92,7 @@ group :test do
 end
 
 group :development do
+  gem 'bootsnap', require: false
   gem 'byebug'
   gem 'debug', '~> 1.11'
   gem 'listen'

RALPH_TASK.md

@@ -22,8 +22,8 @@ Running spork and/or spring doesn't seem to help substantially, but maybe they'r
 
 ## Success Criteria
 
-1. [ ] Document exists explaining why tests are slow
-2. [ ] Document explains solution(s) to why tests are slow
+1. [x] Document exists explaining why tests are slow
+2. [x] Document explains solution(s) to why tests are slow
 3. [ ] Tests reliably load/run faster
 
 ---

config/boot.rb

@@ -5,3 +5,19 @@
 $LOAD_PATH.unshift(File.expand_path('../middleware', __dir__))
 
 require 'bundler/setup' # Set up gems listed in the Gemfile.
+
+# Speed up boot time by caching require calls
+if ENV.fetch('DISABLE_BOOTSNAP', nil).nil?
+  begin
+    require 'bootsnap'
+    Bootsnap.setup(
+      cache_dir: File.join(__dir__, '..', 'tmp', 'cache'),
+      development_mode: ENV.fetch('RAILS_ENV', 'development') != 'production',
+      load_path_cache: true,
+      compile_cache_iseq: true,
+      compile_cache_yaml: true
+    )
+  rescue LoadError
+    # bootsnap is optional, continue without it
+  end
+end

config/spring.rb

@@ -0,0 +1,19 @@
+Spring.application_root = File.expand_path('..', __dir__)
+
+# Files that should trigger a restart when changed
+Spring.watch(
+  '.ruby-version',
+  'Gemfile',
+  'Gemfile.lock',
+  'config/cloud_controller.yml'
+)
+
+# Directories to watch for changes
+%w[
+  lib
+  app
+  config
+  spec/support
+].each do |path|
+  Spring.watch(path)
+end

docs/internal/test_performance.md

@@ -0,0 +1,152 @@
+# Unit Test Performance Analysis
+
+This document explains why unit tests in cloud_controller_ng take a long time to load and proposes solutions.
+
+## The Problem
+
+Running a single unit test like `bundle exec rspec spec/unit/actions/app_create_spec.rb` takes approximately 20 seconds to load and only ~1.7 seconds to actually run. The load time dominates total test time.
+
+## Root Causes
+
+### 1. Eager Loading of the Entire Application (~1400 Ruby files)
+
+The `spec_helper.rb` requires `cloud_controller.rb` which triggers a cascade of requires:
+
+- `cloud_controller.rb` loads ~120 files directly from `lib/`
+- `cloud_controller/controllers.rb` loads all 117 controller files via `Dir[]`
+- `models.rb` loads 162 model files
+- `services.rb` loads service-related code
+- All 105 support files in `spec/support/` are loaded via `Dir[]`
+
+This eager loading happens on every test run, even for a single spec file.
+
+### 2. No Bootsnap Caching
+
+[Bootsnap](https://github.com/shopify/bootsnap) is a library that caches `require` calls (both the file path resolution and the compiled instruction sequences). It can reduce boot time by 50-70% for large Ruby applications.
+
+This project does not use bootsnap.
+
+### 3. Spring Not Properly Configured
+
+Spring and spring-commands-rspec are in the Gemfile, but Spring is not configured:
+
+- No `config/spring.rb` file exists to specify what to watch
+- Spring doesn't know which directories to preload
+- Without configuration, Spring may not preload the application effectively
+
+The bin/rspec attempts to use Spring, but without proper configuration, it may not be helping.
+
+### 4. Spork is Outdated and Ineffective
+
+The spec_helper.rb contains code to support Spork, but:
+
+- Spork is loaded from an old git ref and is no longer maintained
+- The implementation checks if spork is running via `ps | grep spork` which adds overhead
+- Spork has been superseded by Spring
+
+### 5. Database Setup on Every Run
+
+`SpecBootstrap.init` is called on every test run with:
+
+- `recreate_test_tables: true` (default) - recreates database tables
+- `do_schema_migration: true` (default) - runs migration checks
+
+These database operations add to startup time.
+
+## Solutions
+
+### Solution 1: Add Bootsnap (Recommended - Low Risk)
+
+Bootsnap can be added with minimal changes and provides significant speedup.
+
+**Implementation:**
+
+1. Add bootsnap to Gemfile:
+
+```ruby
+group :development, :test do
+  gem 'bootsnap', require: false
+end
+```
+
+2. Add to `config/boot.rb` before other requires:
+
+```ruby
+require 'bootsnap/setup' if ENV.fetch('DISABLE_BOOTSNAP', nil).nil?
+```
+
+**Expected benefit:** 30-50% reduction in boot time with no risk to test behavior.
+
+### Solution 2: Properly Configure Spring (Recommended - Medium Risk)
+
+Create a proper Spring configuration so the preloader works effectively.
+
+**Implementation:**
+
+1. Create `config/spring.rb`:
+
+```ruby
+Spring.application_root = File.expand_path('..', __dir__)
+
+Spring.watch(
+  '.ruby-version',
+  'Gemfile',
+  'Gemfile.lock'
+)
+
+# Watch the lib directory for changes
+%w[lib app spec/support].each do |path|
+  Spring.watch path
+end
+```
+
+2. Regenerate binstubs:
+
+```bash
+bundle exec spring binstub rspec
+```
+
+3. Verify Spring is running:
+
+```bash
+bin/spring status
+```
+
+**Expected benefit:** After first run, subsequent runs should complete in 1-3 seconds.
+
+### Solution 3: Remove Spork (Cleanup - Low Risk)
+
+Remove the outdated Spork code from spec_helper.rb to simplify the codebase.
+
+**Implementation:**
+
+Remove lines 5-13 and 225-239 from spec_helper.rb that deal with Spork, keeping only the `init_block.call` and `each_run_block.call` lines.
+
+### Solution 4: Skip Database Migration Checks
+
+Use the `NO_DB_MIGRATION=true` environment variable:
+
+```bash
+NO_DB_MIGRATION=true bundle exec rspec spec/unit/actions/app_create_spec.rb
+```
+
+This skips migration checks when the schema is known to be up-to-date.
+
+**Expected benefit:** Saves 1-2 seconds per run.
+
+## Recommended Approach
+
+1. **First**: Add bootsnap (lowest risk, immediate benefit)
+2. **Second**: Configure Spring properly (requires testing, but greatest benefit for iterative development)
+3. **Third**: Remove Spork code (cleanup)
+4. **Optional**: Use NO_DB_MIGRATION when appropriate
+
+## Verification
+
+After implementing changes, measure improvement with:
+
+```bash
+time bundle exec rspec spec/unit/actions/app_create_spec.rb --format progress
+```
+
+Compare the total time before and after each change.