feat(tests): support nextest junit + enable colour output (#838)

Co-authored-by: Marc Jakobi <[email protected]>

Author: jorgemmsilva

lua/rustaceanvim/cache.lua

@@ -0,0 +1,38 @@
+local M = {}
+
+--- Nextest profile used to generate junit reports (needs to be written to a toml file)
+--- IMPORTANT: When modifying this config, increment the revision suffix in the file name below!
+local NEXTEST_CONFIG = [[# profile used to generate junit reports when in nextest mode
+[profile.rustaceanvim.junit]
+path = "junit.xml"
+store-failure-output = true
+store-success-output = true
+]]
+
+---@return string path to nextest.toml file
+function M.nextest_config_path()
+  local cache_dir = vim.fs.joinpath(vim.fn.stdpath('cache'), 'rustaceanvim')
+  local config_path = vim.fs.joinpath(cache_dir, 'nextest_1.toml')
+
+  -- Check if file already exists
+  local stat = vim.uv.fs_stat(config_path)
+  if stat then
+    return config_path
+  end
+
+  -- Create cache directory if it doesn't exist
+  vim.fn.mkdir(cache_dir, 'p')
+
+  -- Write the config file
+  local file = io.open(config_path, 'w')
+  if not file then
+    error('Failed to create nextest config file: ' .. config_path)
+  end
+
+  file:write(NEXTEST_CONFIG)
+  file:close()
+
+  return config_path
+end
+
+return M

lua/rustaceanvim/executors/background.lua

@@ -13,6 +13,21 @@ local M = {}
 ---@class rustaceanvim.Diagnostic: vim.Diagnostic
 ---@field test_id string
 
+---@param path string
+---@return string content
+local function read_file(path)
+  local file_fd, open_err = vim.uv.fs_open(path, 'r', 438)
+  assert(not open_err, open_err)
+  assert(file_fd, 'expected file descriptor')
+  local stat, stat_err = vim.uv.fs_fstat(file_fd)
+  assert(not stat_err, stat_err)
+  assert(stat, 'expected file stats')
+  local data, read_err = vim.uv.fs_read(file_fd, stat.size, 0)
+  assert(data, 'expected file content')
+  assert(not read_err, read_err)
+  return data
+end
+
 M.execute_command = function(command, args, cwd, opts)
   ---@type rustaceanvim.ExecutorOpts
   opts = vim.tbl_deep_extend('force', { bufnr = 0 }, opts or {})
@@ -27,7 +42,6 @@ M.execute_command = function(command, args, cwd, opts)
   local is_single_test = args[1] == 'test'
   local notify_prefix = (is_single_test and 'test ' or 'tests ')
   local cmd = vim.list_extend({ command }, args)
-  local fname = vim.api.nvim_buf_get_name(opts.bufnr)
   vim.system(cmd, { cwd = cwd, env = opts.env }, function(sc)
     ---@cast sc vim.SystemCompleted
     if sc.code == 0 then
@@ -38,7 +52,18 @@ M.execute_command = function(command, args, cwd, opts)
       return
     end
     local output = (sc.stderr or '') .. '\n' .. (sc.stdout or '')
-    local diagnostics = require('rustaceanvim.test').parse_diagnostics(fname, output, opts.bufnr)
+    local diagnostics
+    local is_cargo_test = args[1] == 'test'
+    if is_cargo_test then
+      diagnostics = require('rustaceanvim.test').parse_cargo_test_diagnostics(output, opts.bufnr)
+    else
+      local junit_xml = read_file((cwd or vim.fn.getcwd()) .. '/target/nextest/rustaceanvim/junit.xml')
+      if not junit_xml then
+        vim.notify('Failed to read junit.xml file', vim.log.levels.ERROR)
+        return
+      end
+      diagnostics = require('rustaceanvim.test').parse_nextest_diagnostics(junit_xml, opts.bufnr)
+    end
     local summary = get_test_summary(sc.stdout or '')
     vim.schedule(function()
       vim.diagnostic.set(diag_namespace, opts.bufnr, diagnostics)

lua/rustaceanvim/neotest/init.lua

@@ -243,6 +243,8 @@ end
 ---@field pos_id string
 ---@field type neotest.PositionType
 ---@field tree neotest.Tree
+---@field workspace_root string?
+---@field is_cargo_test boolean
 
 ---@package
 ---@param run_args neotest.RunArgs
@@ -263,13 +265,15 @@ function NeotestAdapter.build_spec(run_args)
   if not runnable then
     return
   end
+  local exe, args, cwd, env = require('rustaceanvim.runnables').get_command(runnable)
   local context = {
     file = pos.path,
     pos_id = pos.id,
     type = pos.type,
     tree = tree,
+    workspace_root = NeotestAdapter.root(pos.path),
+    is_cargo_test = args[1] == 'test',
   }
-  local exe, args, cwd, env = require('rustaceanvim.runnables').get_command(runnable)
   if run_args.strategy == 'dap' then
     local dap = require('rustaceanvim.dap')
     overrides.sanitize_command_for_debugging(runnable.args.cargoArgs)
@@ -303,16 +307,8 @@ function NeotestAdapter.build_spec(run_args)
   else
     overrides.undo_debug_sanitize(runnable.args.cargoArgs)
   end
-  local is_cargo_test = args[1] == 'test'
-  local insert_pos = is_cargo_test and 2 or 3
+  local insert_pos = context.is_cargo_test and 2 or 3
   table.insert(args, insert_pos, '--no-fail-fast')
-  if is_cargo_test then
-    -- cargo test needs to pass --color=never to the test runner too
-    table.insert(args, '--color=never')
-  else
-    table.insert(args, 2, '--color')
-    table.insert(args, 3, 'never')
-  end
   ---@type rustaceanvim.neotest.RunSpec
   ---@diagnostic disable-next-line: missing-fields
   local run_spec = {
@@ -349,54 +345,78 @@ function NeotestAdapter.results(spec, strategy_result)
   local context = spec.context
   local ctx_pos_id = context.pos_id
   ---@type string
-  local output_content = lib.files.read(strategy_result.output)
   if strategy_result.code == 0 then
     results[ctx_pos_id] = {
       status = 'passed',
       output = strategy_result.output,
     }
     return results
   end
-  ---@type table<string,neotest.Error[]>
-  local errors_by_test_id = {}
-  output_content = output_content:gsub('\r\n', '\n')
-  local diagnostics = require('rustaceanvim.test').parse_diagnostics(context.file, output_content, 0)
-  for _, diagnostic in pairs(diagnostics) do
-    ---@type neotest.Error
-    local err = {
-      line = diagnostic.lnum,
-      message = diagnostic.message,
-    }
-    errors_by_test_id[diagnostic.test_id] = errors_by_test_id[diagnostic.test_id] or {}
-    table.insert(errors_by_test_id[diagnostic.test_id], err)
+
+  ---@type rustaceanvim.Diagnostic[]
+  local diagnostics
+  local output_content = ''
+  local junit_xml = ''
+  if context.is_cargo_test then
+    local success
+    success, output_content = pcall(function()
+      return lib.files.read(strategy_result.output)
+    end)
+    if not success then
+      vim.notify('Failed to read output file', vim.log.levels.ERROR)
+      return results
+    end
+    diagnostics = require('rustaceanvim.test').parse_cargo_test_diagnostics(output_content, 0)
+  else
+    local success
+    success, junit_xml = pcall(function()
+      return lib.files.read(
+        vim.fs.joinpath(context.workspace_root or vim.fn.getcwd(), 'target', 'nextest', 'rustaceanvim', 'junit.xml')
+      )
+    end)
+    if not success then
+      vim.notify('Failed to read junit.xml file', vim.log.levels.ERROR)
+      return results
+    end
+    diagnostics = require('rustaceanvim.test').parse_nextest_diagnostics(junit_xml, 0)
   end
+
   if not vim.tbl_contains({ 'file', 'test', 'namespace' }, context.type) then
     return results
   end
   results[ctx_pos_id] = {
     status = 'failed',
     output = strategy_result.output,
   }
-  local has_failures = not vim.tbl_isempty(diagnostics)
+
+  if vim.tbl_isempty(diagnostics) then
+    return results -- no failures
+  end
+
   for _, node in get_file_root(context.tree):iter_nodes() do
     local data = node:data()
-    for test_id, errors in pairs(errors_by_test_id) do
-      if vim.endswith(data.id, test_id) then
-        results[data.id] = {
-          status = 'failed',
-          errors = errors,
-          short = output_content,
-        }
-      elseif has_failures and data.type == 'test' then
-        -- Initialise as skipped. Passed positions will be parsed and set later.
-        results[data.id] = {
-          status = 'skipped',
-        }
-      end
+    local failure_diagnostic = vim.iter(diagnostics):find(function(diag)
+      return vim.endswith(data.id, diag.test_id)
+    end)
+
+    if failure_diagnostic then
+      results[data.id] = {
+        status = 'failed',
+        errors = { { line = failure_diagnostic.lnum, message = failure_diagnostic.message } },
+        short = failure_diagnostic.message,
+      }
+    elseif data.type == 'test' then
+      -- Initialise as skipped. Passed positions will be parsed and set later.
+      results[data.id] = {
+        status = 'skipped',
+      }
     end
   end
-  if has_failures then
-    require('rustaceanvim.neotest.parser').populate_pass_positions(results, context, output_content)
+
+  if context.is_cargo_test then
+    require('rustaceanvim.neotest.parser').populate_pass_positions_cargo_test(results, context, output_content)
+  else
+    require('rustaceanvim.neotest.parser').populate_pass_positions_nextest(results, context, junit_xml)
   end
   return results
 end

lua/rustaceanvim/neotest/parser.lua

@@ -6,33 +6,33 @@ local trans = require('rustaceanvim.neotest.trans')
 ---
 ---@param results table<string, neotest.Result>
 ---@param context rustaceanvim.neotest.RunContext
----@param output_content string
+---@param junit_xml string
 ---@return table<string, neotest.Result> results
-function M.populate_pass_positions(results, context, output_content)
-  -- XXX: match doesn't work here because it needs to
-  -- match on the end of each line
-  -- TODO: Use cargo-nextest's JUnit output in the future?
-  local lines = vim.split(output_content, '\n') or {}
-  vim
-    .iter(lines)
-    ---@param line string
-    :map(function(line)
-      return line:match('PASS%s.*%s(%S+)$') or line:match('test%s(%S+)%s...%sok')
-    end)
-    ---@param result string | nil
-    :filter(function(result)
-      return result ~= nil
-    end)
-    ---@param pos string
-    :map(function(pos)
-      return trans.get_position_id(context.file, pos)
-    end)
-    ---@param pos string
-    :each(function(pos)
-      results[pos] = {
+function M.populate_pass_positions_nextest(results, context, junit_xml)
+  for test_name, contents in junit_xml:gmatch('<testcase.-name="([^"]+)".->(.-)</testcase>') do
+    if not contents:match('</failure>') then
+      results[trans.get_position_id(context.file, test_name)] = {
         status = 'passed',
       }
-    end)
+    end
+  end
+
+  return results
+end
+
+---NOTE: This mutates results
+---
+---@param results table<string, neotest.Result>
+---@param context rustaceanvim.neotest.RunContext
+---@param output_content string
+---@return table<string, neotest.Result> results
+function M.populate_pass_positions_cargo_test(results, context, output_content)
+  -- NOTE: ignore ANSI character for ok, if present: ^[[32mok^[[0;10m
+  for test_name in output_content:gmatch('\ntest%s+([^\n]-)%s+%.%.%.%s+\27?%[?[0-9;]-m?ok\27?%[?[0-9;]-m?\r?\n') do
+    results[trans.get_position_id(context.file, test_name)] = {
+      status = 'passed',
+    }
+  end
   return results
 end
 

lua/rustaceanvim/overrides.lua

@@ -33,6 +33,28 @@ function M.snippet_text_edits_to_text_edits(text_edits)
   end
 end
 
+---@param arg_list string[] list of arguments
+---@return string[] runner args
+---@return string[] executable args
+local function partition_executable_args(arg_list)
+  local delimiter = '--'
+  local before = {}
+  local after = {}
+  local found_delimiter = false
+
+  for _, value in ipairs(arg_list) do
+    if value == delimiter then
+      found_delimiter = true
+    elseif not found_delimiter then
+      table.insert(before, value)
+    else
+      table.insert(after, value)
+    end
+  end
+
+  return before, after
+end
+
 ---Transforms the args to cargo-nextest args if it is detected.
 ---Mutates command!
 ---@param args string[]
@@ -44,23 +66,43 @@ function M.try_nextest_transform(args)
     args[1] = 'run'
     table.insert(args, 1, 'nextest')
   end
-  if args[#args] == '--nocapture' then
-    table.insert(args, 3, '--nocapture')
-    table.remove(args, #args)
+  local nextest_args, executable_args = partition_executable_args(args)
+
+  -- specify custom profile for junit output
+  table.insert(nextest_args, '--profile')
+  table.insert(nextest_args, 'rustaceanvim')
+  table.insert(nextest_args, '--config-file')
+  table.insert(nextest_args, require('rustaceanvim.cache').nextest_config_path())
+
+  -- tranform `-- test_something --exact` into `-E 'test("test_something")'`
+  for i = 1, #executable_args do
+    if executable_args[i] == '--exact' then
+      local test_name = executable_args[i - 1]
+      table.remove(executable_args, i - 1)
+      table.remove(executable_args, i - 1)
+      table.insert(nextest_args, test_name)
+      break
+    end
   end
+
   local nextest_unsupported_flags = {
     '--show-output',
   }
   local indexes_to_remove_reverse_order = {}
-  for i, arg in ipairs(args) do
+  for i, arg in ipairs(executable_args) do
     if vim.list_contains(nextest_unsupported_flags, arg) then
       table.insert(indexes_to_remove_reverse_order, 1, i)
     end
   end
   for _, i in pairs(indexes_to_remove_reverse_order) do
-    table.remove(args, i)
+    table.remove(executable_args, i)
+  end
+
+  table.insert(nextest_args, '--')
+  for _, v in ipairs(executable_args) do
+    table.insert(nextest_args, v)
   end
-  return args
+  return nextest_args
 end
 
 -- sanitize_command_for_debugging substitutes the command arguments so it can be used to run a