DEBUG

Author: vinistock

test/integration_test.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "test_helper"
+require "timeout"
 
 class IntegrationTest < Minitest::Test
   def setup
@@ -374,24 +375,17 @@ def test_launch_mode_update_does_not_modify_main_lockfile
   end
 
   def test_launch_mode_retries_if_setup_failed_after_successful_install
-    # RubyGems asks for confirmation when uninstalling a gem, so we need to be able to write the `y` to stdin
-    uninstall_rails = ->() {
-      stdin, _stdout, _stderr, wait_thread = Open3.popen3("gem", "uninstall", "rails")
-      stdin.write("y\n")
-      wait_thread.join
-    }
-
     in_temp_dir do |dir|
       File.write(File.join(dir, "Gemfile"), <<~RUBY)
         source "https://rubygems.org"
-        gem "rails"
+        gem "rails", "8.1.1"
       RUBY
 
       Bundler.with_unbundled_env do
         # Generate a lockfile first
         capture_subprocess_io { system("bundle", "install") }
         # Uninstall the gem so that composing the bundle has to install it
-        uninstall_rails.call
+        system("gem", "uninstall", "rails", "-v", "8.1.1", "--executables", "--silent")
 
         # Preemptively create the bundle_env file and acquire an exclusive lock on it, so that composing the bundle will
         # have to pause immediately after bundle installing, but before invoking Bundler.setup
@@ -400,14 +394,19 @@ def test_launch_mode_retries_if_setup_failed_after_successful_install
         FileUtils.touch(bundle_env_path)
 
         thread = Thread.new do
-          File.open(bundle_env_path) do |f|
-            f.flock(File::LOCK_EX)
-
+          file = File.open(bundle_env_path)
+          begin
+            file.flock(File::LOCK_EX)
             # Give the bundle compose enough time to finish and get stuck on the lock
             sleep(2)
             # Uninstall Rails after successfully bundle installing and before invoking Bundler.setup, which will cause
             # it to fail with `Bundler::GemNotFound`. This triggers our retry mechanism
-            uninstall_rails.call
+            system("gem", "uninstall", "rails", "-v", "8.1.1", "--executables", "--silent")
+          rescue => e
+            flunk(e.full_message)
+          ensure
+            file.flock(File::LOCK_UN)
+            file.close
           end
         end
 
@@ -437,49 +436,59 @@ def test_launching_an_older_server_version
   private
 
   def launch(workspace_path, exec = "ruby-lsp-launcher", extra_env = {})
-    stdin, stdout, stderr, wait_thr = Open3 #: as untyped
-      .popen3(
-        extra_env,
-        Gem.ruby,
-        File.join(__dir__, "..", "exe", exec),
-      )
-    stdin.sync = true
-    stdin.binmode
-    stdout.sync = true
-    stdout.binmode
-    stderr.sync = true
-    stderr.binmode
-
-    send_message(stdin, {
-      id: 1,
-      method: "initialize",
-      params: {
-        initializationOptions: {},
-        capabilities: { general: { positionEncodings: ["utf-8"] } },
-        workspaceFolders: [{ uri: URI::Generic.from_path(path: workspace_path).to_s }],
-      },
-    })
-
-    # First message is the log of initializing Ruby LSP
-    read_message(stdout, stderr)
-    # Verify that initialization didn't fail
-    initialize_response = read_message(stdout, stderr)
-    refute(initialize_response[:error], initialize_response.dig(:error, :message))
-
-    send_message(stdin, { id: 2, method: "shutdown" })
-    send_message(stdin, { method: "exit" })
-
-    # Wait until the process exits
-    wait_thr.join
-
-    # If the child process failed, it is really difficult to diagnose what's happening unless we read what was printed
-    # to stderr
-    unless wait_thr.value.success?
-      require "timeout"
-
-      Timeout.timeout(5) do
-        flunk("Process failed\n#{stderr.read}")
+    stdin = nil #: IO?
+    stdout = nil #: IO?
+    stderr = nil #: IO?
+
+    begin
+      Timeout.timeout(180) do
+        stdin, stdout, stderr, wait_thr = Open3 #: as untyped
+          .popen3(
+            extra_env,
+            Gem.ruby,
+            File.join(__dir__, "..", "exe", exec),
+          )
+        stdin.sync = true
+        stdin.binmode
+        stdout.sync = true
+        stdout.binmode
+        stderr.sync = true
+        stderr.binmode
+
+        send_message(stdin, {
+          id: 1,
+          method: "initialize",
+          params: {
+            initializationOptions: {},
+            capabilities: { general: { positionEncodings: ["utf-8"] } },
+            workspaceFolders: [{ uri: URI::Generic.from_path(path: workspace_path).to_s }],
+          },
+        })
+
+        # First message is the log of initializing Ruby LSP
+        read_message(stdout, stderr)
+        # Verify that initialization didn't fail
+        initialize_response = read_message(stdout, stderr)
+        refute(initialize_response[:error], initialize_response.dig(:error, :message))
+
+        send_message(stdin, { id: 2, method: "shutdown" })
+        send_message(stdin, { method: "exit" })
+
+        # Wait until the process exits
+        wait_thr.join
+      end
+    rescue Timeout::Error
+      if stderr
+        Timeout.timeout(5) { flunk("Launching the server timed out\n#{stderr.read}") }
+      end
+
+      if stdout
+        Timeout.timeout(5) { flunk("Launching the server timed out\n#{stdout.read}") }
       end
+    ensure
+      stdin&.close
+      stdout&.close
+      stderr&.close
     end
 
     assert_path_exists(File.join(workspace_path, ".ruby-lsp", "Gemfile"))