ruby-lsp 0.23.11 → 0.23.16

data/lib/ruby_lsp/server.rb

@@ -3,13 +3,12 @@
 
 module RubyLsp
   class Server < BaseServer
-    extend T::Sig
-
     # Only for testing
-    sig { returns(GlobalState) }
+    #: GlobalState
     attr_reader :global_state
 
-    sig { override.params(message: T::Hash[Symbol, T.untyped]).void }
+    # @override
+    #: (Hash[Symbol, untyped] message) -> void
     def process_message(message)
       case message[:method]
       when "initialize"
@@ -112,6 +111,10 @@ module RubyLsp
         diagnose_state(message)
       when "rubyLsp/discoverTests"
         discover_tests(message)
+      when "rubyLsp/resolveTestCommands"
+        resolve_test_commands(message)
+      when "experimental/goToRelevantFile"
+        experimental_go_to_relevant_file(message)
       when "$/cancelRequest"
         @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
@@ -161,7 +164,7 @@ module RubyLsp
     end
 
     # Process responses to requests that were sent to the client
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def process_response(message)
       case message.dig(:result, :method)
       when "window/showMessageRequest"
@@ -169,7 +172,7 @@ module RubyLsp
       end
     end
 
-    sig { params(include_project_addons: T::Boolean).void }
+    #: (?include_project_addons: bool) -> void
     def load_addons(include_project_addons: true)
       # If invoking Bundler.setup failed, then the load path will not be configured properly and trying to load add-ons
       # with Gem.find_files will find every single version installed of an add-on, leading to requiring several
@@ -209,7 +212,7 @@ module RubyLsp
 
     private
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def run_initialize(message)
       options = message[:params]
       global_state_notifications = @global_state.apply_options(options)
@@ -220,7 +223,8 @@ module RubyLsp
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
 
       configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
-      T.must(@store.features_configuration.dig(:inlayHint)).configuration.merge!(configured_hints) if configured_hints
+      @store.features_configuration.dig(:inlayHint) #: as !nil
+        .configuration.merge!(configured_hints) if configured_hints
 
       enabled_features = case configured_features
       when Array
@@ -290,6 +294,8 @@ module RubyLsp
           experimental: {
             addon_detection: true,
             compose_bundle: true,
+            go_to_relevant_file: true,
+            full_test_discovery: true,
           },
         ),
         serverInfo: {
@@ -346,7 +352,7 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def run_initialized
       load_addons
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
@@ -373,7 +379,7 @@ module RubyLsp
       check_formatter_is_available
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_open(message)
       @global_state.synchronize do
         text_document = message.dig(:params, :textDocument)
@@ -412,7 +418,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_close(message)
       @global_state.synchronize do
         uri = message.dig(:params, :textDocument, :uri)
@@ -423,7 +429,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_did_change(message)
       params = message[:params]
       text_document = params[:textDocument]
@@ -433,7 +439,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_selection_range(message)
       uri = message.dig(:params, :textDocument, :uri)
       ranges = @store.cache_fetch(uri, "textDocument/selectionRange") do |document|
@@ -459,7 +465,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def run_combined_requests(message)
       uri = URI(message.dig(:params, :textDocument, :uri))
       document = @store.get(uri)
@@ -484,7 +490,11 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
-      inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
+      inlay_hint = Requests::InlayHints.new(
+        document,
+        @store.features_configuration.dig(:inlayHint), #: as !nil
+        dispatcher,
+      )
 
       if document.is_a?(RubyDocument) && document.should_index?
         # Re-index the file as it is modified. This mode of indexing updates entries only. Require path trees are only
@@ -518,7 +528,7 @@ module RubyLsp
     alias_method :text_document_code_lens, :run_combined_requests
     alias_method :text_document_folding_range, :run_combined_requests
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_semantic_tokens_full(message)
       document = @store.get(message.dig(:params, :textDocument, :uri))
 
@@ -539,7 +549,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: semantic_highlighting.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_semantic_tokens_delta(message)
       document = @store.get(message.dig(:params, :textDocument, :uri))
 
@@ -564,7 +574,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_semantic_tokens_range(message)
       params = message[:params]
       range = params[:range]
@@ -593,7 +603,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_range_formatting(message)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       if @global_state.formatter == "none"
@@ -621,7 +631,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_formatting(message)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       if @global_state.formatter == "none"
@@ -665,7 +675,7 @@ module RubyLsp
       send_empty_response(message[:id])
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_document_highlight(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -681,7 +691,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_on_type_formatting(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -704,7 +714,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_hover(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -729,7 +739,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_rename(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -749,7 +759,7 @@ module RubyLsp
       send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::REQUEST_FAILED, message: e.message))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_prepare_rename(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -767,7 +777,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_references(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -785,7 +795,7 @@ module RubyLsp
       )
     end
 
-    sig { params(document: Document[T.untyped]).returns(RubyDocument::SorbetLevel) }
+    #: (Document[untyped] document) -> RubyDocument::SorbetLevel
     def sorbet_level(document)
       return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker
       return RubyDocument::SorbetLevel::Ignore unless document.is_a?(RubyDocument)
@@ -793,7 +803,7 @@ module RubyLsp
       document.sorbet_level
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_inlay_hint(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -811,7 +821,7 @@ module RubyLsp
         return
       end
 
-      hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
+      hints_configurations = @store.features_configuration.dig(:inlayHint) #: as !nil
       dispatcher = Prism::Dispatcher.new
 
       unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
@@ -827,7 +837,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: result.select { |hint| range.cover?(hint.position[:line]) }))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_code_action(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -849,7 +859,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def code_action_resolve(message)
       params = message[:params]
       uri = URI(params.dig(:data, :uri))
@@ -874,7 +884,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_diagnostic(message)
       # Do not compute diagnostics for files outside of the workspace. For example, if someone is looking at a gem's
       # source code, we don't want to show diagnostics for it
@@ -914,7 +924,7 @@ module RubyLsp
       send_empty_response(message[:id])
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_completion(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -939,7 +949,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_completion_item_resolve(message)
       # When responding to a delegated completion request, it means we're handling a completion item that isn't related
       # to Ruby (probably related to an ERB host language like HTML). We need to return the original completion item
@@ -958,7 +968,7 @@ module RubyLsp
       ))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_signature_help(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -984,7 +994,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_definition(message)
       params = message[:params]
       dispatcher = Prism::Dispatcher.new
@@ -1009,8 +1019,23 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def workspace_did_change_watched_files(message)
+      # If indexing is not complete yet, delay processing did change watched file notifications. We need initial
+      # indexing to be in place so that we can handle file changes appropriately without risking duplicates. We also
+      # have to sleep before re-inserting the notification in the queue otherwise the worker can get stuck in its own
+      # loop of pushing and popping the same notification
+      unless @global_state.index.initial_indexing_completed
+        Thread.new do
+          sleep(2)
+          # We have to ensure that the queue is not closed yet, since nothing stops the user from saving a file and then
+          # immediately telling the LSP to shutdown
+          @incoming_queue << message unless @incoming_queue.closed?
+        end
+
+        return
+      end
+
       changes = message.dig(:params, :changes)
       # We allow add-ons to register for watching files and we have no restrictions for what they register for. If the
       # same pattern is registered more than once, the LSP will receive duplicate change notifications. Receiving them
@@ -1037,7 +1062,8 @@ module RubyLsp
       end
 
       Addon.file_watcher_addons.each do |addon|
-        T.unsafe(addon).workspace_did_change_watched_files(changes)
+        addon #: as untyped
+          .workspace_did_change_watched_files(changes)
       rescue => e
         send_log_message(
           "Error in #{addon.name} add-on while processing watched file notifications: #{e.full_message}",
@@ -1046,32 +1072,34 @@ module RubyLsp
       end
     end
 
-    sig { params(index: RubyIndexer::Index, file_path: String, change_type: Integer).void }
+    #: (RubyIndexer::Index index, String file_path, Integer change_type) -> void
     def handle_ruby_file_change(index, file_path, change_type)
-      load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
-      uri = URI::Generic.from_path(load_path_entry: load_path_entry, path: file_path)
-
-      content = File.read(file_path)
-
-      case change_type
-      when Constant::FileChangeType::CREATED
-        # If we receive a late created notification for a file that has already been claimed by the client, we want to
-        # handle change for that URI so that the require path tree is updated
-        @store.key?(uri) ? index.handle_change(uri, content) : index.index_single(uri, content)
-      when Constant::FileChangeType::CHANGED
-        # We only handle changes on file watched notifications if the client is not the one managing this URI.
-        # Otherwise, these changes are handled when running the combined requests
-        index.handle_change(uri, content) unless @store.key?(uri)
-      when Constant::FileChangeType::DELETED
-        index.delete(uri)
-      end
-    rescue Errno::ENOENT
-      # If a file is created and then delete immediately afterwards, we will process the created notification before we
-      # receive the deleted one, but the file no longer exists. This may happen when running a test suite that creates
-      # and deletes files automatically.
+      @global_state.synchronize do
+        load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
+        uri = URI::Generic.from_path(load_path_entry: load_path_entry, path: file_path)
+
+        case change_type
+        when Constant::FileChangeType::CREATED
+          content = File.read(file_path)
+          # If we receive a late created notification for a file that has already been claimed by the client, we want to
+          # handle change for that URI so that the require path tree is updated
+          @store.key?(uri) ? index.handle_change(uri, content) : index.index_single(uri, content)
+        when Constant::FileChangeType::CHANGED
+          content = File.read(file_path)
+          # We only handle changes on file watched notifications if the client is not the one managing this URI.
+          # Otherwise, these changes are handled when running the combined requests
+          index.handle_change(uri, content) unless @store.key?(uri)
+        when Constant::FileChangeType::DELETED
+          index.delete(uri)
+        end
+      rescue Errno::ENOENT
+        # If a file is created and then delete immediately afterwards, we will process the created notification before
+        # we receive the deleted one, but the file no longer exists. This may happen when running a test suite that
+        # creates and deletes files automatically.
+      end
     end
 
-    sig { params(uri: URI::Generic).void }
+    #: (URI::Generic uri) -> void
     def handle_rubocop_config_change(uri)
       return unless defined?(Requests::Support::RuboCopFormatter)
 
@@ -1091,7 +1119,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def workspace_symbol(message)
       send_message(
         Result.new(
@@ -1104,7 +1132,7 @@ module RubyLsp
       )
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_show_syntax_tree(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -1123,7 +1151,26 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
+    def experimental_go_to_relevant_file(message)
+      path = message.dig(:params, :textDocument, :uri).to_standardized_path
+      unless path.nil? || path.start_with?(@global_state.workspace_path)
+        send_empty_response(message[:id])
+        return
+      end
+
+      unless path
+        send_empty_response(message[:id])
+        return
+      end
+
+      response = {
+        locations: Requests::GoToRelevantFile.new(path, @global_state.workspace_path).perform,
+      }
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
+    #: (Hash[Symbol, untyped] message) -> void
     def text_document_prepare_type_hierarchy(message)
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
@@ -1142,7 +1189,7 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def type_hierarchy_supertypes(message)
       response = Requests::TypeHierarchySupertypes.new(
         @global_state.index,
@@ -1151,14 +1198,14 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def type_hierarchy_subtypes(message)
       # TODO: implement subtypes
       # The current index representation doesn't allow us to find the children of an entry.
       send_message(Result.new(id: message[:id], response: nil))
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def workspace_dependencies(message)
       unless @global_state.top_level_bundle
         send_message(Result.new(id: message[:id], response: []))
@@ -1186,12 +1233,13 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
-    sig { override.void }
+    # @override
+    #: -> void
     def shutdown
       Addon.unload_addons
     end
 
-    sig { void }
+    #: -> void
     def perform_initial_indexing
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
@@ -1223,7 +1271,7 @@ module RubyLsp
       end
     end
 
-    sig { params(id: String, title: String, percentage: Integer).void }
+    #: (String id, String title, ?percentage: Integer) -> void
     def begin_progress(id, title, percentage: 0)
       return unless @global_state.client_capabilities.supports_progress
 
@@ -1236,14 +1284,14 @@ module RubyLsp
       send_message(Notification.progress_begin(id, title, percentage: percentage, message: "#{percentage}% completed"))
     end
 
-    sig { params(id: String, percentage: Integer).void }
+    #: (String id, Integer percentage) -> void
     def progress(id, percentage)
       return unless @global_state.client_capabilities.supports_progress
 
       send_message(Notification.progress_report(id, percentage: percentage, message: "#{percentage}% completed"))
     end
 
-    sig { params(id: String).void }
+    #: (String id) -> void
     def end_progress(id)
       return unless @global_state.client_capabilities.supports_progress
 
@@ -1253,7 +1301,7 @@ module RubyLsp
       # notification
     end
 
-    sig { void }
+    #: -> void
     def check_formatter_is_available
       return if @setup_error
       # Warn of an unavailable `formatter` setting, e.g. `rubocop_internal` on a project which doesn't have RuboCop.
@@ -1271,7 +1319,7 @@ module RubyLsp
       end
     end
 
-    sig { params(indexing_options: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    #: (Hash[Symbol, untyped]? indexing_options) -> void
     def process_indexing_configuration(indexing_options)
       # Need to use the workspace URI, otherwise, this will fail for people working on a project that is a symlink.
       index_path = File.join(@global_state.workspace_path, ".index.yml")
@@ -1312,7 +1360,7 @@ module RubyLsp
       configuration.apply_config(indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase })
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def window_show_message_request(message)
       result = message[:result]
       return unless result
@@ -1327,7 +1375,7 @@ module RubyLsp
     # NOTE: all servers methods are void because they can produce several messages for the client. The only reason this
     # method returns the created thread is to that we can join it in tests and avoid flakiness. The implementation is
     # not supposed to rely on the return of this method
-    sig { params(message: T::Hash[Symbol, T.untyped]).returns(T.nilable(Thread)) }
+    #: (Hash[Symbol, untyped] message) -> Thread?
     def compose_bundle(message)
       already_composed_path = File.join(@global_state.workspace_path, ".ruby-lsp", "bundle_is_composed")
       id = message[:id]
@@ -1352,7 +1400,9 @@ module RubyLsp
           Open3.capture3(
             Gem.ruby,
             "-I",
-            File.dirname(T.must(__dir__)),
+            File.dirname(
+              __dir__, #: as !nil
+            ),
             File.expand_path("../../exe/ruby-lsp-launcher", __dir__),
             @global_state.workspace_uri.to_s,
             chdir: @global_state.workspace_path,
@@ -1374,7 +1424,7 @@ module RubyLsp
     end
 
     # Returns internal state information for debugging purposes
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def diagnose_state(message)
       documents = {}
       @store.each { |uri, document| documents[uri] = document.source }
@@ -1394,7 +1444,7 @@ module RubyLsp
 
     # Discovers all available test groups and examples in a given file taking into consideration the merged response of
     # all add-ons
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def discover_tests(message)
       document = @store.get(message.dig(:params, :textDocument, :uri))
 
@@ -1414,5 +1464,23 @@ module RubyLsp
 
       send_message(Result.new(id: message[:id], response: items.map(&:to_hash)))
     end
+
+    #: (Hash[Symbol, untyped] message) -> void
+    def resolve_test_commands(message)
+      items = message.dig(:params, :items)
+      commands = Listeners::TestStyle.resolve_test_commands(items)
+
+      Addon.addons.each do |addon|
+        commands.concat(addon.resolve_test_commands(items))
+      end
+
+      send_message(Result.new(
+        id: message[:id],
+        response: {
+          commands: commands,
+          reporterPaths: [Listeners::TestStyle::MINITEST_REPORTER_PATH, Listeners::TestStyle::TEST_UNIT_REPORTER_PATH],
+        },
+      ))
+    end
   end
 end