Merge pull request #596 from Shopify/ar/command-resolution

Add Rails test command resolution

Author: alexcrocha

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -93,6 +93,12 @@ def create_discover_tests_listener(response_builder, dispatcher, uri)
         RailsTestStyle.new(@rails_runner_client, response_builder, @global_state, dispatcher, uri)
       end
 
+      # @override
+      #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+      def resolve_test_commands(items)
+        RailsTestStyle.resolve_test_commands(items)
+      end
+
       # Creates a new CodeLens listener. This method is invoked on every CodeLens request
       # @override
       #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void

lib/ruby_lsp/ruby_lsp_rails/rails_test_style.rb

@@ -4,6 +4,52 @@
 module RubyLsp
   module Rails
     class RailsTestStyle < Listeners::TestDiscovery
+      BASE_COMMAND = "#{RbConfig.ruby} bin/rails test" #: String
+
+      class << self
+        #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+        def resolve_test_commands(items)
+          commands = []
+          queue = items.dup
+
+          full_files = []
+
+          until queue.empty?
+            item = T.must(queue.shift)
+            tags = Set.new(item[:tags])
+            next unless tags.include?("framework:rails")
+
+            children = item[:children]
+            uri = URI(item[:uri])
+            path = uri.full_path
+            next unless path
+
+            if tags.include?("test_dir")
+              if children.empty?
+                full_files.concat(Dir.glob(
+                  "#{path}/**/{*_test,test_*}.rb",
+                  File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
+                ))
+              end
+            elsif tags.include?("test_file")
+              full_files << path if children.empty?
+            elsif tags.include?("test_group")
+              commands << "#{BASE_COMMAND} #{path} --name \"/#{Shellwords.escape(item[:id])}(#|::)/\""
+            else
+              full_files << "#{path}:#{item.dig(:range, :start, :line) + 1}"
+            end
+
+            queue.concat(children)
+          end
+
+          unless full_files.empty?
+            commands << "#{BASE_COMMAND} #{full_files.join(" ")}"
+          end
+
+          commands
+        end
+      end
+
       #: (RunnerClient client, ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def initialize(client, response_builder, global_state, dispatcher, uri)
         super(response_builder, global_state, dispatcher, uri)
@@ -45,7 +91,12 @@ def on_call_node_enter(node)
         test_name = first_arg.content
         test_name = "<empty test name>" if test_name.empty?
 
-        add_test_item(node, test_name)
+        # Rails' `test "foo bar"` helper defines a method `def test_foo_bar`. We normalize test names
+        # the same way (spaces to underscores, prefix with `test_`) to match the actual method names
+        # Rails uses at runtime, ensuring proper test discovery and execution.
+        rails_normalized_name = "test_#{test_name.gsub(/\s+/, "_")}"
+
+        add_test_item(node, rails_normalized_name)
       end
 
       #: (Prism::DefNode node) -> void

test/ruby_lsp_rails/rails_test_style_test.rb

@@ -26,8 +26,8 @@ class SampleTest < ActiveSupport::TestCase
           assert_equal(2, test_class[:children].length)
 
           test_labels = test_class[:children].map { |i| i[:label] }
-          assert_includes(test_labels, "first test")
-          assert_includes(test_labels, "second test")
+          assert_includes(test_labels, "test_first_test")
+          assert_includes(test_labels, "test_second_test")
           assert_all_items_tagged_with(items, :rails)
         end
       end
@@ -52,7 +52,7 @@ class EmptyTest < ActiveSupport::TestCase
           assert_equal(2, test_class[:children].length)
 
           test_labels = test_class[:children].map { |i| i[:label] }
-          assert_includes(test_labels, "<empty test name>")
+          assert_includes(test_labels, "test_<empty_test_name>")
           assert_all_items_tagged_with(items, :rails)
         end
       end
@@ -110,11 +110,11 @@ def test_second_test
       test "handles tests with special characters in name" do
         source = <<~RUBY
           class SpecialCharsTest < ActiveSupport::TestCase
-            test "test with spaces and punctuation!" do
+            test "spaces and punctuation!" do
               assert true
             end
 
-            test "test with unicode: 你好" do
+            test "unicode: 你好" do
               assert true
             end
           end
@@ -127,12 +127,107 @@ class SpecialCharsTest < ActiveSupport::TestCase
           assert_equal(2, test_class[:children].length)
 
           test_labels = test_class[:children].map { |i| i[:label] }
-          assert_includes(test_labels, "test with spaces and punctuation!")
-          assert_includes(test_labels, "test with unicode: 你好")
+          assert_includes(test_labels, "test_spaces_and_punctuation!")
+          assert_includes(test_labels, "test_unicode:_你好")
           assert_all_items_tagged_with(items, :rails)
         end
       end
 
+      test "resolve test command entire files" do
+        base_dir = Gem.win_platform? ? "D:/other/test" : "/other/test"
+        test_paths = [
+          File.join(base_dir, "fake_test.rb"),
+          File.join(base_dir, "fake_test2.rb"),
+        ]
+        Dir.stubs(:glob).returns(test_paths)
+
+        with_server do |server|
+          sleep(0.1) while RubyLsp::Addon.addons.first.instance_variable_get(:@rails_runner_client).is_a?(NullClient)
+
+          server.process_message({
+            id: 1,
+            method: "rubyLsp/resolveTestCommands",
+            params: {
+              items: [
+                {
+                  id: "file:///test/server_test.rb",
+                  uri: "file:///test/server_test.rb",
+                  label: "/test/server_test.rb",
+                  tags: ["test_file", "framework:rails"],
+                  children: [],
+                },
+                {
+                  id: "file:///other/test",
+                  uri: "file:///other/test",
+                  label: "/other/test",
+                  tags: ["test_dir", "framework:rails"],
+                  children: [],
+                },
+              ],
+            },
+          })
+
+          result = pop_result(server)
+          response = result.response
+
+          assert_equal(
+            [
+              "#{RailsTestStyle::BASE_COMMAND} /test/server_test.rb #{test_paths.join(" ")}",
+            ],
+            response[:commands],
+          )
+        end
+      end
+
+      test "resolve test command group test" do
+        with_server do |server|
+          sleep(0.1) while RubyLsp::Addon.addons.first.instance_variable_get(:@rails_runner_client).is_a?(NullClient)
+
+          server.process_message({
+            id: 1,
+            method: "rubyLsp/resolveTestCommands",
+            params: {
+              items: [
+                {
+                  id: "GroupTest",
+                  uri: "file:///test/group_test.rb",
+                  label: "GroupTest",
+                  range: {
+                    start: { line: 0, character: 0 },
+                    end: { line: 30, character: 3 },
+                  },
+                  tags: ["framework:rails", "test_group"],
+                  children: [
+                    {
+                      id: "GroupTest#test_example",
+                      uri: "file:///test/group_test.rb",
+                      label: "test_example",
+                      range: {
+                        start: { line: 1, character: 2 },
+                        end: { line: 10, character: 3 },
+                      },
+                      tags: ["framework:rails"],
+                      children: [],
+                    },
+                  ],
+                },
+              ],
+            },
+          })
+
+          result = pop_result(server)
+          response = result.response
+
+          assert_equal(
+            [
+              "#{RailsTestStyle::BASE_COMMAND} /test/group_test.rb --name \"/GroupTest(#|::)/\"",
+              "#{RailsTestStyle::BASE_COMMAND} /test/group_test.rb:2",
+            ],
+            response[:commands],
+          )
+        end
+      end
+
       private
 
       def with_active_support_declarative_tests(source, file: "/fake.rb", &block)