Test template caching by booting apps with ActiveSupport::Testing::Isolation

Boot a fresh development or production app per test in a forked process,
the way railties tests do, instead of an Open3 subprocess or an extracted
method. These tests run in their own rake task since the sandbox is
already booted in the test process.

Inline the executor hook back into the engine, and restore #2730's
integration tests that a previous commit dropped by mistake.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f2e356ff-16cd-4517-8e63-a8600747d3fa

Author: joelhawksley

Rakefile

@@ -14,7 +14,13 @@ RSpec::Core::RakeTask.new(:spec)
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"].exclude("test/isolated/**/*")
+end
+
+# Each test boots its own application, so these can't share a process with the sandbox.
+Rake::TestTask.new(:isolated_test) do |t|
+  t.libs << "lib"
+  t.test_files = FileList["test/isolated/**/*_test.rb"]
 end
 
 Rake::TestTask.new(:engine_test) do |t|
@@ -176,6 +182,10 @@ task :all_tests do
   Rake::Task["test"].invoke
   puts
   puts
+  puts "Running isolated Minitests"
+  Rake::Task["isolated_test"].invoke
+  puts
+  puts
   puts "Running Minitests for Rails Engine compatibility"
   Rake::Task["engine_test"].invoke
   puts

lib/view_component/compile_cache.rb

@@ -34,20 +34,5 @@ def template_watcher(file_watcher)
 
       file_watcher.new([], directories) { invalidate! }
     end
-
-    # Like Rails' own template cache expiry, only watches templates when they
-    # aren't cached at boot. With template caching on, as in production, no
-    # hook runs per request, so requests never read ActionView's caching
-    # class variable, which non-main Ractors can't access.
-    def watch_templates(app)
-      return if ActionView::Base.cache_template_loading
-
-      watcher = nil
-
-      app.executor.to_run :before do
-        watcher ||= CompileCache.template_watcher(app.config.file_watcher)
-        watcher.execute_if_updated
-      end
-    end
   end
 end

lib/view_component/engine.rb

@@ -132,7 +132,20 @@ class Engine < Rails::Engine # :nodoc:
         end
       end
 
-      ActiveSupport.on_load(:action_view) { CompileCache.watch_templates(app) }
+      # Like Rails' own template cache expiry, only watch templates when they
+      # aren't cached at boot. With template caching on, as in production, no
+      # hook runs per request, so requests never read ActionView's caching
+      # class variable, which non-main Ractors can't access.
+      ActiveSupport.on_load(:action_view) do
+        next if ActionView::Base.cache_template_loading
+
+        template_watcher = nil
+
+        app.executor.to_run :before do
+          template_watcher ||= CompileCache.template_watcher(app.config.file_watcher)
+          template_watcher.execute_if_updated
+        end
+      end
 
       app.reloader.before_class_unload { CompileCache.invalidate! }
     end

test/isolated/template_caching_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "minitest/autorun"
+require "minitest/mock"
+require "rails"
+require "action_controller/railtie"
+require "active_support/testing/isolation"
+require "view_component"
+
+# Boots a fresh application per test in a forked process, so tests can choose
+# their own environment. Runs separately from the sandbox, which boots in test.
+class TemplateCachingTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def test_executor_checks_for_template_changes_when_templates_are_not_cached
+    app = boot_app("development")
+    refute ActionView::Base.cache_template_loading
+
+    watcher = Minitest::Mock.new
+    watcher.expect(:execute_if_updated, nil)
+    ViewComponent::CompileCache.stub(:template_watcher, watcher) { app.executor.wrap {} }
+
+    watcher.verify
+  end
+
+  # Non-main Ractors can't read ActionView::Resolver's class variable on Ruby 4.0,
+  # so the executor must not read it on every request when templates are cached.
+  def test_executor_does_nothing_when_templates_are_cached
+    app = boot_app("production")
+    assert ActionView::Base.cache_template_loading
+
+    reads = 0
+    ActionView::Resolver.singleton_class.prepend(Module.new do
+      define_method(:caching?) do
+        reads += 1
+        super()
+      end
+    end)
+    ViewComponent::CompileCache.stub(:template_watcher, ->(*) { flunk "templates were watched" }) { app.executor.wrap {} }
+
+    assert_equal 0, reads
+  end
+
+  private
+
+  def boot_app(env)
+    Rails.env = env
+
+    Class.new(Rails::Application) do
+      config.root = __dir__
+      config.eager_load = env == "production"
+      config.enable_reloading = env == "development"
+      config.secret_key_base = "test"
+      config.logger = Logger.new(nil)
+    end.tap(&:initialize!)
+  end
+end

test/sandbox/test/initializers/engine_test.rb

@@ -7,28 +7,4 @@ def test_set_no_duplicate_autoload_paths
     test_path = "#{Rails.root}/my/components/previews" # set in sandbox/config/application.rb
     assert_equal 1, ActiveSupport::Dependencies.autoload_paths.count(test_path)
   end
-
-  # Non-main Ractors can't read ActionView::Resolver's class variable on Ruby 4.0,
-  # so no per-request hook may read it when templates are cached.
-  def test_watch_templates_registers_no_executor_hook_when_templates_are_cached
-    app = app_with_new_executor
-
-    with_template_caching { ViewComponent::CompileCache.watch_templates(app) }
-
-    assert_empty app.executor._run_callbacks
-  end
-
-  def test_watch_templates_registers_an_executor_hook_when_templates_are_not_cached
-    app = app_with_new_executor
-
-    with_new_cache { ViewComponent::CompileCache.watch_templates(app) }
-
-    assert_equal 1, app.executor._run_callbacks.count
-  end
-
-  private
-
-  def app_with_new_executor
-    Struct.new(:executor, :config).new(Class.new(ActiveSupport::Executor), Rails.application.config)
-  end
 end

test/sandbox/test/integration_test.rb

@@ -86,6 +86,33 @@ def test_template_changes_are_reflected_on_new_request_when_cache_template_loadi
     end
   end
 
+  def test_components_are_not_recompiled_on_new_request_when_no_template_changed
+    with_new_cache do
+      get "/controller_inline"
+      MyComponent.__vc_compile
+
+      get "/controller_inline"
+      assert_response :success
+      assert MyComponent.__vc_compiled?
+    end
+  end
+
+  def test_components_are_recompiled_on_new_request_when_a_template_is_added
+    new_template = Rails.root.join("app/components/added_template_component.html.erb")
+
+    with_new_cache do
+      get "/controller_inline"
+      MyComponent.__vc_compile
+
+      File.write(new_template, "<div>Added</div>")
+      get "/controller_inline"
+      assert_response :success
+      refute MyComponent.__vc_compiled?
+    end
+  ensure
+    FileUtils.rm_f(new_template)
+  end
+
   def test_inherited_template_changes_are_reflected_on_new_request_when_cache_template_loading_is_false
     with_new_cache do
       get "/inherited_sidecar"

test/test_helper.rb

@@ -133,7 +133,7 @@ def with_generate_sidecar(enabled, &block)
 def with_template_caching
   executor = Rails.application.executor
   watcher_hook = executor._run_callbacks.find do |callback|
-    callback.filter.is_a?(Proc) && callback.filter.source_location&.first&.end_with?("view_component/compile_cache.rb")
+    callback.filter.is_a?(Proc) && callback.filter.source_location&.first&.end_with?("view_component/engine.rb")
   end&.filter
   executor.skip_callback(:run, :before, watcher_hook) if watcher_hook