Update tests (not working yet)

Author: andyw8

test/ruby_lsp_rails/server_test.rb

@@ -6,26 +6,52 @@
 
 class ServerTest < ActiveSupport::TestCase
   setup do
-    @server = RubyLsp::Rails::Server.new
+    @mutex = T.let(Mutex.new, Mutex)
+
+    stdin, stdout, stderr, wait_thread = Bundler.with_original_env do
+      path = "#{__dir__}/../../lib/ruby_lsp/ruby_lsp_rails/server.rb"
+      Open3.popen3(
+        "bundle",
+        "exec",
+        "rails",
+        "runner",
+        path,
+        "start",
+      )
+    end
+
+    @stdin = T.let(stdin, IO)
+    @stdout = T.let(stdout, IO)
+    @stderr = T.let(stderr, IO)
+    @wait_thread = T.let(wait_thread, Process::Waiter)
+  end
+
+  teardown do
+    if @wait_thread.alive?
+      $stderr.puts("Ruby LSP Rails is force killing the server")
+      sleep(0.5) # give the server a bit of time if we already issued a shutdown notification
+      force_kill
+    end
   end
 
   test "returns nil if model doesn't exist" do
-    response = @server.execute("model", { name: "Foo" })
+    response = make_request("model", { name: "Foo" })
+    # binding.break
     assert_nil(response.fetch(:result))
   end
 
   test "returns nil if class is not a model" do
-    response = @server.execute("model", { name: "Time" })
+    response = make_request("model", { name: "Time" })
     assert_nil(response.fetch(:result))
   end
 
   test "returns nil if class is an abstract model" do
-    response = @server.execute("model", { name: "ApplicationRecord" })
+    response = make_request("model", { name: "ApplicationRecord" })
     assert_nil(response.fetch(:result))
   end
 
   test "returns nil if constant is not a class" do
-    response = @server.execute("model", { name: "RUBY_VERSION" })
+    response = make_request("model", { name: "RUBY_VERSION" })
     assert_nil(response.fetch(:result))
   end
 
@@ -38,21 +64,21 @@ def <(other)
       end
     end
 
-    response = @server.execute("model", { name: "TestClassWithOverwrittenLessThan" })
+    response = make_request("model", { name: "TestClassWithOverwrittenLessThan" })
     assert_nil(response.fetch(:result))
   end
 
   test "handles older Rails version which don't have `schema_dump_path`" do
     ActiveRecord::Tasks::DatabaseTasks.send(:alias_method, :old_schema_dump_path, :schema_dump_path)
     ActiveRecord::Tasks::DatabaseTasks.undef_method(:schema_dump_path)
-    response = @server.execute("model", { name: "User" })
+    response = make_request("model", { name: "User" })
     assert_nil(response.fetch(:result)[:schema_file])
   ensure
     ActiveRecord::Tasks::DatabaseTasks.send(:alias_method, :schema_dump_path, :old_schema_dump_path)
   end
 
   test "resolve association returns the location of the target class of a has_many association" do
-    response = @server.execute(
+    response = make_request(
       "association_target_location",
       { model_name: "Organization", association_name: :memberships },
     )
@@ -61,7 +87,7 @@ def <(other)
   end
 
   test "resolve association returns the location of the target class of a belongs_to association" do
-    response = @server.execute(
+    response = make_request(
       "association_target_location",
       { model_name: "Membership", association_name: :organization },
     )
@@ -70,7 +96,7 @@ def <(other)
   end
 
   test "resolve association returns the location of the target class of a has_one association" do
-    response = @server.execute(
+    response = make_request(
       "association_target_location",
       { model_name: "User", association_name: :profile },
     )
@@ -79,7 +105,7 @@ def <(other)
   end
 
   test "resolve association returns the location of the target class of a has_and_belongs_to_many association" do
-    response = @server.execute(
+    response = make_request(
       "association_target_location",
       { model_name: "Profile", association_name: :labels },
     )
@@ -88,23 +114,23 @@ def <(other)
   end
 
   test "resolve association handles invalid model name" do
-    response = @server.execute(
+    response = make_request(
       "association_target_location",
       { model_name: "NotHere", association_name: :labels },
     )
     assert_nil(response.fetch(:result))
   end
 
   test "resolve association handles invalid association name" do
-    response = @server.execute(
+    response = make_request(
       "association_target_location",
       { model_name: "Membership", association_name: :labels },
     )
     assert_nil(response.fetch(:result))
   end
 
   test "resolve association handles class_name option" do
-    response = @server.execute(
+    response = make_request(
       "association_target_location",
       { model_name: "User", association_name: :location },
     )
@@ -113,18 +139,18 @@ def <(other)
   end
 
   test "route location returns the location for a valid route" do
-    response = @server.execute("route_location", { name: "user_path" })
+    response = make_request("route_location", { name: "user_path" })
     location = response[:result][:location]
     assert_match %r{test/dummy/config/routes.rb:4$}, location
   end
 
   test "route location returns nil for invalid routes" do
-    response = @server.execute("route_location", { name: "invalid_path" })
+    response = make_request("route_location", { name: "invalid_path" })
     assert_nil response[:result]
   end
 
   test "route info" do
-    response = @server.execute("route_info", { controller: "UsersController", action: "index" })
+    response = make_request("route_info", { controller: "UsersController", action: "index" })
 
     result = response[:result]
 
@@ -152,4 +178,52 @@ def resolve_route_info(requirements)
     assert_empty(stdout)
     assert_equal("Hello\n", stderr)
   end
+
+  private
+
+  def make_request(request, params = nil)
+    send_message(request, params)
+    read_response
+  end
+
+  def send_message(request, params = nil)
+    message = { method: request }
+    message[:params] = params if params
+    json = message.to_json
+
+    @mutex.synchronize do
+      @stdin.write("Content-Length: #{json.length}\r\n\r\n", json)
+    end
+    # rescue Errno::EPIPE
+    # The server connection died
+  end
+
+  def read_response
+    raw_response = @mutex.synchronize do
+      headers = @stdout.gets("\r\n\r\n")
+      raise "IncompleteMessageError" unless headers
+
+      content_length = headers[/Content-Length: (\d+)/i, 1].to_i
+      raise "EmptyMessageError" if content_length.zero?
+
+      @stdout.read(content_length)
+    end
+
+    response = JSON.parse(T.must(raw_response), symbolize_names: true)
+
+    if response[:error]
+      $stderr.puts("Ruby LSP Rails error: " + response[:error])
+      return
+    end
+
+    response.fetch(:result)
+    # rescue Errno::EPIPE
+    # The server connection died
+    # nil
+  end
+
+  def force_kill
+    # Windows does not support the `TERM` signal, so we're forced to use `KILL` here
+    Process.kill(T.must(Signal.list["KILL"]), @wait_thread.pid)
+  end
 end