Adapt bundler jobserver specs to build logs no longer installed

These specs read the `make -jN` command line from `gem_make.out`, which a
successful build no longer writes. The integration specs in `install_spec`
now force the build to fail so the command lands in `build_info`, and the
`parallel_installer` specs assert on the number of jobserver slots each
gem's build acquired, which is exactly what becomes `make -jN`, instead of
reading a build log.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: hsbt

spec/bundler/installer/parallel_installer_spec.rb

@@ -149,34 +149,37 @@
     let(:gem_two) { definition.specs.find {|spec| spec.name == "two" } }
 
     it "takes all available slots" do
-      redefine_build_jobs do
+      acquired = track_build_jobs(rendezvous: true) do
         Bundler::ParallelInstaller.call(installer, definition.specs, 5, false, true)
       end
 
-      # Take 3 slots out of the 5 available.
-      expect(File.read(File.join(gem_one.extension_dir, "gem_make.out"))).to include("make -j3")
+      # Take 3 slots (capped per gem) out of the 5 available.
+      expect(acquired["one"]).to eq(3)
       # Take the remaining 2 slots.
-      expect(File.read(File.join(gem_two.extension_dir, "gem_make.out"))).to include("make -j2")
+      expect(acquired["two"]).to eq(2)
     end
 
     it "fallback to non parallel when no slots are available" do
-      redefine_build_jobs do
+      acquired = track_build_jobs(rendezvous: true) do
         Bundler::ParallelInstaller.call(installer, definition.specs, 3, false, true)
       end
 
       # Take 3 slots out of the 3 available.
-      expect(File.read(File.join(gem_one.extension_dir, "gem_make.out"))).to include("make -j3")
+      expect(acquired["one"]).to eq(3)
       # Fallback to one slot (non parallel).
-      expect(File.read(File.join(gem_two.extension_dir, "gem_make.out"))).to_not include("make -j")
+      expect(acquired["two"]).to eq(1)
     end
 
     it "uses one jobs when installing serially" do
+      acquired = nil
       Bundler.settings.temporary(jobs: 1) do
-        Bundler::ParallelInstaller.call(installer, definition.specs, 1, false, true)
+        acquired = track_build_jobs do
+          Bundler::ParallelInstaller.call(installer, definition.specs, 1, false, true)
+        end
       end
 
-      expect(File.read(File.join(gem_one.extension_dir, "gem_make.out"))).to_not include("make -j")
-      expect(File.read(File.join(gem_two.extension_dir, "gem_make.out"))).to_not include("make -j")
+      expect(acquired["one"]).to eq(1)
+      expect(acquired["two"]).to eq(1)
     end
 
     it "release the job slots" do
@@ -188,39 +191,52 @@
         end
       end
 
-      Bundler::ParallelInstaller.call(installer, definition.specs, 3, false, true)
+      acquired = track_build_jobs do
+        Bundler::ParallelInstaller.call(installer, definition.specs, 3, false, true)
+      end
 
       # Take 3 slots out of the 3 available.
-      expect(File.read(File.join(gem_one.extension_dir, "gem_make.out"))).to include("make -j3")
-      # Take 3 slots that were released.
-      expect(File.read(File.join(gem_two.extension_dir, "gem_make.out"))).to include("make -j3")
+      expect(acquired["one"]).to eq(3)
+      # Take 3 slots that were released by `one`.
+      expect(acquired["two"]).to eq(3)
     end
 
-    def redefine_build_jobs
+    # Records how many jobserver slots each gem's build acquired. RubyGems turns
+    # that count directly into `make -jN`, so asserting on it verifies slot
+    # allocation and release without reading a build log, which a successful
+    # build no longer writes. With +rendezvous+, "one" grabs its slots first and
+    # holds them until "two" has grabbed the rest, making the split deterministic.
+    def track_build_jobs(rendezvous: false)
+      acquired = {}
       old_method = Bundler::RubyGemsGemInstaller.instance_method(:build_jobs)
       Bundler::RubyGemsGemInstaller.remove_method(:build_jobs)
 
-      # Rendezvous so that "one" grabs its slots first and keeps holding them
-      # until "two" has grabbed the rest. Blocking on a queue avoids the
-      # busy-wait and makes the ordering deterministic.
       one_acquired = Thread::Queue.new
       two_acquired = Thread::Queue.new
 
       Bundler::RubyGemsGemInstaller.define_method(:build_jobs) do
-        if spec.name == "one"
-          value = old_method.bind(self).call
-          one_acquired << true
-          two_acquired.pop
-        elsif spec.name == "two"
-          one_acquired.pop
-          value = old_method.bind(self).call
-          two_acquired << true
-        end
+        value =
+          if rendezvous && spec.name == "one"
+            v = old_method.bind(self).call
+            one_acquired << true
+            two_acquired.pop
+            v
+          elsif rendezvous && spec.name == "two"
+            one_acquired.pop
+            v = old_method.bind(self).call
+            two_acquired << true
+            v
+          else
+            old_method.bind(self).call
+          end
 
+        acquired[spec.name] = value
         value
       end
 
       yield
+
+      acquired
     ensure
       Bundler::RubyGemsGemInstaller.remove_method(:build_jobs)
       Bundler::RubyGemsGemInstaller.define_method(:build_jobs, old_method)

spec/commands/install_spec.rb

@@ -1369,10 +1369,18 @@ def run
           s.extensions = extension
 
           s.write(extension, extconf_code)
+          # A successful build no longer leaves gem_make.out behind. Force the
+          # build to fail at the make stage so the make command line, including
+          # the jobserver `-j`, is recorded in build_info for these assertions.
+          s.write("ext/mypsych/mypsych.c", "#error forced build failure for test")
         end
       end
     end
 
+    def gem_make_out
+      File.read(File.join(@gemspec.build_info_dir, "#{@gemspec.full_name}.gem_make.out"))
+    end
+
     after do
       if @old_makeflags
         ENV["MAKEFLAGS"] = @old_makeflags
@@ -1384,39 +1392,33 @@ def run
     it "doesn't pass down -j to make when MAKEFLAGS is set" do
       ENV["MAKEFLAGS"] = "-j1"
 
-      install_gemfile(<<~G, env: { "BUNDLE_JOBS" => "8" })
+      install_gemfile(<<~G, env: { "BUNDLE_JOBS" => "8" }, raise_on_error: false)
         source "https://gem.repo4"
         gem "mypsych"
       G
 
-      gem_make_out = File.read(File.join(@gemspec.extension_dir, "gem_make.out"))
-
       expect(gem_make_out).not_to include("make -j8")
     end
 
     it "uses 3 slots from the available pool when running the compilation of an extension", rubygems: ">= 4.1.0.dev" do
       ENV.delete("MAKEFLAGS")
 
-      install_gemfile(<<~G, env: { "BUNDLE_JOBS" => "8" })
+      install_gemfile(<<~G, env: { "BUNDLE_JOBS" => "8" }, raise_on_error: false)
         source "https://gem.repo4"
         gem "mypsych"
       G
 
-      gem_make_out = File.read(File.join(@gemspec.extension_dir, "gem_make.out"))
-
       expect(gem_make_out).to include("make -j3")
     end
 
     it "consumes 3 slots from the pool when BUNDLE_JOBS isn't set", rubygems: ">= 4.1.0.dev" do
       ENV.delete("MAKEFLAGS")
 
-      install_gemfile(<<~G)
+      install_gemfile(<<~G, raise_on_error: false)
         source "https://gem.repo4"
         gem "mypsych"
       G
 
-      gem_make_out = File.read(File.join(@gemspec.extension_dir, "gem_make.out"))
-
       expect(gem_make_out).to include("make -j3")
     end
   end