utest.nvim @ db3688a

---@class utest.Adapter

---@field ft string

---@field query string

---@field is_subtest fun(name:string):boolean

---@field get_cwd fun(file:string):string

---@field test_file_command fun(file:string):string[]

---@field test_command fun(test:utest.Test, file:string)

---@field parse_output fun(output:string[], file:string):utest.AdapterTestResult

---@field extract_test_output fun(output:string[], test_name:string|nil):string[]

---@field extract_error_message fun(output:string[]):string|nil

---@alias utest.TestStatus "success"|"fail"|"running"|"skipped"

---@class utest.Test

---@field name string

---@field file string

---@field line number

---@field end_line number

---@field col number

---@field end_col number

---@field is_subtest boolean

---@field parent string|nil

---@class utest.AdapterTestResult

---@field name string

---@field status utest.TestStatus

---@field output string[]

---@field error_line number|nil

---@class utest.Job

---@field job_id number

---@field test_id string

---@field file string

---@field name string

---@field line number

---@field start_time number

---@class utest.JobResult

---@field status utest.TestStatus

---@field output string

---@field raw_output? string

---@field timestamp number

---@field file string

---@field error_message? string

---@field name? string

---@field line? number

local test_failed_msg = "[Test failed]"

local H = {

  ---@type table<string, utest.Adapter>

  adapters = {},

  ---@type table<string, vim.treesitter.Query>

  queries = {},

  ---@type table<string, utest.Job>

  jobs = {},

  ---@type table<string, utest.JobResult>

  results = {},

  sns = nil,

  dns = nil,

  extmarks = {},

  diagnostics = {},

}

local utest = {}

utest.config = {

  timeout = 30,

  icons = {

    failed = "",

    running = "",

    skipped = "",

    success = "",

  },

}

function utest.setup(opts)

  utest.config = vim.tbl_deep_extend("keep", utest.config, opts)

  H.sns = vim.api.nvim_create_namespace "utest_signs"

  H.dns = vim.api.nvim_create_namespace "utest_diagnostics"

  H.adapters.go = require "utest.golang"

end

function utest.run()

  local bufnr = vim.api.nvim_get_current_buf()

  local adapter = H.adapters[vim.bo[bufnr].filetype]

  if not adapter then

    vim.notify("[utest] no adapter for this filetype", vim.log.levels.WARN)

    return

  end

  local cursor_line = vim.api.nvim_win_get_cursor(0)[1] - 1

  local test = H.find_nearest_test(bufnr, cursor_line, adapter)

  if not test then

    vim.notify("[utest] no near test found", vim.log.levels.INFO)

    return

  end

  H.execute_test(test, adapter, bufnr)

end

function utest.run_file()

  local bufnr = vim.api.nvim_get_current_buf()

  local adapter = H.adapters[vim.bo[bufnr].filetype]

  if not adapter then

    vim.notify("[utest] no adapter for this filetype", vim.log.levels.WARN)

    return

  end

  local tests = H.find_tests(bufnr, adapter)

  if #tests == 0 then

    vim.notify("[utest] no tests found in file", vim.log.levels.INFO)

    return

  end

  for _, test in ipairs(tests) do

    H.execute_test(test, adapter, bufnr)

  end

end

function utest.cancel()

  local cancelled = 0

  for id, info in pairs(H.jobs) do

    pcall(vim.fn.jobstop, id)

    if info.test_id then

      H.results[info.test_id] = {

        status = "fail",

        output = "",

        error_message = "Test cancelled",

        timestamp = os.time(),

        file = info.file,

        line = info.line,

        name = info.name,

      }

    end

    cancelled = cancelled + 1

  end

  H.jobs = {}

  if cancelled > 0 then

    vim.notify("[utest] cancelled running test(s)", vim.log.levels.INFO)

  else

    vim.notify("[utest] no running tests to cancel", vim.log.levels.INFO)

  end

end

function utest.clear()

  local bufnr = vim.api.nvim_get_current_buf()

  H.clear_file(vim.api.nvim_buf_get_name(bufnr))

  H.signs_clear_buffer(bufnr)

  H.diagnostics_clear_buffer(bufnr)

  H.qf_clear()

end

function utest.qf()

  local qfitems = {}

  for test_id, result in pairs(H.get_failed()) do

    local file, line, name = test_id:match "^(.+):(%d+):(.+)$"

    if file and line then

      local error_text = result.output or result.error_message or test_failed_msg

      local lines = vim.split(error_text, "\n", { plain = true })

      for i, lcontent in ipairs(lines) do

        lcontent = vim.trim(lcontent)

        if lcontent ~= "" then

          local text = (i == 1) and (name .. ": " .. lcontent) or ("  " .. lcontent)

          table.insert(qfitems, {

            filename = file,

            lnum = tonumber(line) + 1,

            col = 1,

            text = text,

            type = "E",

          })

        end

      end

    end

  end

  if #qfitems == 0 then

    vim.notify("[utest] No failed tests", vim.log.levels.INFO)

    return

  end

  vim.fn.setqflist({}, "r", { title = "utest: failed tests", items = qfitems })

end

-- HELPERS ====================================================================

function H.make_test_id(file, line, name)

  return string.format("%s:%d:%s", file, line, name)

end

function H.clear_file(file)

  for id, _ in pairs(H.results) do

    if id:match("^" .. vim.pesc(file) .. ":") then H.results[id] = nil end

  end

end

function H.get_failed()

  local f = {}

  for id, r in pairs(H.results) do

    if r.status == "fail" then f[id] = r end

  end

  return f

end

function H.qf_clear()

  local qf = vim.fn.getqflist { title = 1 }

  if qf.title == "utest: failed tests" then vim.fn.setqflist({}, "r") end

end

-- SIGNS

---@type table<utest.TestStatus, string>

local sign_highlights = {

  success = "DiagnosticOk",

  skipped = "DiagnosticInfo",

  fail = "DiagnosticError",

  running = "DiagnosticInfo",

}

---@param bufnr number

---@param line number

---@param status utest.TestStatus

---@param test_id string

function H.sign_place(bufnr, line, status, test_id)

  if not H.extmarks[bufnr] then H.extmarks[bufnr] = {} end

  local existing_id = H.extmarks[bufnr][test_id]

  if existing_id then

    pcall(vim.api.nvim_buf_del_extmark, bufnr, H.sns, existing_id)

    H.extmarks[bufnr][test_id] = nil

  end

  -- FIXME: might fail if status is invalid

  local icon = utest.config.icons[status]

  local hl = sign_highlights[status]

  local ok, res = pcall(vim.api.nvim_buf_set_extmark, bufnr, H.sns, line, 0, {

    priority = 1000,

    sign_text = icon,

    sign_hl_group = hl,

  })

  if ok and test_id then H.extmarks[bufnr][test_id] = res end

end

--- get current line of a sign y test_id

---@param bufnr number

---@param test_id string

function H.sign_get_current_line(bufnr, test_id)

  if not H.extmarks[bufnr] or not H.extmarks[bufnr][test_id] then return nil end

  local ok, mark =

    pcall(vim.api.nvim_buf_get_extmark_by_id, bufnr, H.sns, H.extmarks[bufnr][test_id], {})

  if ok and mark and #mark >= 1 then return mark[1] end

  return nil

end

---@param bufnr number

function H.signs_clear_buffer(bufnr)

  pcall(vim.api.nvim_buf_clear_namespace, bufnr, H.sns, 0, -1)

  H.extmarks[bufnr] = nil

end

--- clears all utest diagnostics in a buffer

---@param bufnr number

function H.diagnostics_clear_buffer(bufnr)

  H.diagnostics[bufnr] = nil

  vim.diagnostic.reset(H.dns, bufnr)

end

--- clear diagnostic at a specific line

---@param bufnr number

---@param line number 0-indexed line number

function H.diagnostics_clear(bufnr, line)

  if H.diagnostics[bufnr] then

    H.diagnostics[bufnr][line] = nil

    H.diagnostics_refresh(bufnr)

  end

end

--- set diagnostic at a line

---@param bufnr number

---@param line number 0-indexed line number

---@param message string|nil

function H.diagnostics_set(bufnr, line, message)

  if not H.diagnostics[bufnr] then H.diagnostics[bufnr] = {} end

  H.diagnostics[bufnr][line] = {

    lnum = line,

    col = 0,

    severity = vim.diagnostic.severity.ERROR,

    source = "utest",

    message = message or test_failed_msg,

  }

  H.diagnostics_refresh(bufnr)

end

--- refresh diagnostics for a buffer

---@param bufnr number

function H.diagnostics_refresh(bufnr)

  local diags = {}

  if H.diagnostics[bufnr] then

    for _, diag in pairs(H.diagnostics[bufnr]) do

      table.insert(diags, diag)

    end

  end

  vim.diagnostic.set(H.dns, bufnr, diags)

end

-- RUNNER

---@param test utest.Test

---@param adapter utest.Adapter

---@param bufnr number

function H.execute_test(test, adapter, bufnr)

  local cmd = adapter.test_command(test, test.file)

  local test_id = H.make_test_id(test.file, test.line, test.name)

  local output_lines = {}

  local timed_out = false

  H.results[test_id] = {

    status = "running",

    output = "",

    timestamp = os.time(),

    file = test.file,

  }

  H.sign_place(bufnr, test.line, "running", test_id)

  local timeout_timer, job_id = nil, nil

  local function cleanup()

    if timeout_timer then

      timeout_timer:stop()

      timeout_timer:close()

      timeout_timer = nil

    end

    if job_id and H.jobs[job_id] then H.jobs[job_id] = nil end

  end

  local function on_output(_, data, _)

    if data then

      for _, line in ipairs(data) do

        if line ~= "" then table.insert(output_lines, line) end

      end

    end

  end

  local function on_exit(_, exit_code)

    if timed_out then return end

    cleanup()

    local full_output = table.concat(output_lines, "\n")

    local results = adapter.parse_output(output_lines, test.file)

    -- find result for ths specific test

    local test_result = nil

    local search_name = test.name

    if test.is_subtest and test.parent then

      search_name = test.parent .. "/" .. test.name:gsub(" ", "_")

    end

    for _, r in ipairs(results) do

      if r.name == search_name or r.name == test.name then

        test_result = r

        break

      end

    end

    -- fallback: use exit code if no specific result found

    if not test_result then

      test_result = {

        name = test.name,

        status = exit_code == 0 and "success" or "fail",

        output = output_lines,

        error_line = nil,

      }

    end

    -- ensure status validity

    local final_status = test_result.status

    if final_status ~= "success" and final_status ~= "fail" and final_status ~= "skipped" then

      final_status = exit_code == 0 and "success" or "fail"

    end

    test_result.status = final_status

    local test_output = adapter.extract_test_output(output_lines, search_name)

    local error_message = test_result.status == "fail"

        and adapter.extract_error_message(output_lines)

      or nil

    H.results[test_id] = {

      status = test_result.status,

      output = table.concat(test_output, "\n"),

      raw_output = full_output,

      error_message = error_message,

      timestamp = os.time(),

      file = test.file,

      line = test.line,

      name = test.name,

    }

    -- update ui

    vim.schedule(function()

      if not vim.api.nvim_buf_is_valid(bufnr) then return end

      H.sign_place(bufnr, test.line, test_result.status, test_id)

      if test_result.status == "fail" then

        -- Only set diagnostic if there's no diagnostic already at this line

        -- This prevents multiple diagnostics when parent/child tests both fail

        local existing = vim.diagnostic.get(bufnr, { namespace = H.dns, lnum = test.line })

        if #existing == 0 then

          H.diagnostics_set(

            bufnr,

            test.line,

            H.results[test_id].output or H.results[test_id].error_message or test_failed_msg

          )

        end

      else

        H.diagnostics_clear(bufnr, test.line)

      end

    end)

  end

  job_id = vim.fn.jobstart(cmd, {

    cwd = adapter.get_cwd(test.file),

    on_stdout = on_output,

    on_stderr = on_output,

    on_exit = on_exit,

    stdout_buffered = true,

    stderr_buffered = true,

  })

  if job_id < 0 then

    vim.notify("[utest] failed to start test: " .. test.name, vim.log.levels.ERROR)

    cleanup()

    return

  end

  H.jobs[job_id] = {

    job_id = job_id,

    test_id = test_id,

    file = test.file,

    line = test.line,

    name = test.name,

    start_time = os.time(),

    output = output_lines,

  }

  local timeout = utest.config.timeout * 1000

  timeout_timer = vim.uv.new_timer()

  -- stylua: ignore

  timeout_timer:start(timeout, 0, vim.schedule_wrap(function() ---@diagnostic disable-line: need-check-nil

    if H.jobs[job_id] then

      timed_out = true

      vim.fn.jobstop(job_id)

      H.results[test_id] = {

        status = "fail",

        output = table.concat(output_lines, "\n"),

        error_message = "Test timed out after " .. utest.config.timeout .. "s",

        timestamp = os.time(),

        file = test.file,

        line = test.line,

        name = test.name,

      }

      H.sign_place(bufnr, test.line, "fail", test_id)

      H.diagnostics_set(bufnr, test.line, "Test timed out")

      cleanup()

    end

  end))

end

-- TREESITTER PARSER

---@param lang string

---@param query string

---@return vim.treesitter.Query|nil

function H.get_query(lang, query)

  if H.queries[lang] then return H.queries[lang] end

  local ok, q = pcall(vim.treesitter.query.parse, lang, query)

  if not ok then return nil end

  H.queries[lang] = q

  return q

end

---@param bufnr number

---@param adapter utest.Adapter

---@return utest.Test[]

function H.find_tests(bufnr, adapter)

  local query = H.get_query(adapter.ft, adapter.query)

  if not query then

    vim.notify("[utest] failed to run " .. adapter.ft .. " adapter query", vim.log.levels.ERROR)

    return {}

  end

  local pok, parser = pcall(vim.treesitter.get_parser, bufnr, adapter.ft)

  if not pok or not parser then

    vim.notify("[utest] failed to get treesitter parser", vim.log.levels.ERROR)

    return {}

  end

  local tree = parser:parse()[1]

  if not tree then return {} end

  local file = vim.api.nvim_buf_get_name(bufnr)

  local root = tree:root()

  local tests = {}

  for _, match, _ in query:iter_matches(root, bufnr, 0, -1) do

    local test_name, test_def = nil, nil

    for id, nodes in pairs(match) do

      local name = query.captures[id]

      if not name then goto continue_match end

      local node = type(nodes) == "table" and nodes[1] or nodes

      if name == "test.name" then

        test_name = vim.treesitter.get_node_text(node, bufnr)

        test_name = test_name:gsub('^"', ""):gsub('"$', "")

      elseif name == "test.definition" then

        test_def = node

      end

      ::continue_match::

    end

    if test_name and test_def then

      local start_row, start_col, end_row, end_col = test_def:range()

      table.insert(tests, {

        name = test_name,

        file = file,

        line = start_row,

        col = start_col,

        end_line = end_row,

        end_col = end_col,

        is_subtest = adapter.is_subtest(test_name),

        parent = nil,

      })

    end

  end

  -- Deduplicate: when multiple query patterns match overlapping AST regions

  -- (e.g. function_declaration + table test entry), keep the narrower match

  table.sort(tests, function(a, b)

    if a.line ~= b.line then return a.line < b.line end

    return (a.end_line - a.line) < (b.end_line - b.line)

  end)

  local seen = {}

  local deduped = {}

  for _, test in ipairs(tests) do

    local key = test.line .. ":" .. test.name

    if not seen[key] then

      seen[key] = true

      table.insert(deduped, test)

    end

  end

  tests = deduped

  -- Resolve parent relationships for subtests (including nested subtests)

  -- Uses line ranges to determine proper parent hierarchy

  table.sort(tests, function(a, b)

    return a.line < b.line

  end)

  -- Build parent hierarchy by checking which tests contain others based on line ranges

  -- Treesitter uses half-open intervals [start, end), so we use <= for start and < for end

  for i, test in ipairs(tests) do

    if test.is_subtest then

      local innermost_parent = nil

      local innermost_parent_line = -1

      for j, potential_parent in ipairs(tests) do

        if i ~= j then

          -- Check if potential_parent contains this test using line ranges

          if potential_parent.line <= test.line and test.line < potential_parent.end_line then

            -- Found a containing test, check if it's the innermost one

            if potential_parent.line > innermost_parent_line then

              innermost_parent = potential_parent

              innermost_parent_line = potential_parent.line

            end

          end

        end

      end

      if innermost_parent then

        -- Build full parent path for nested subtests

        if innermost_parent.parent then -- TODO: too go dependent

          test.parent = innermost_parent.parent .. "/" .. innermost_parent.name

        else

          test.parent = innermost_parent.name

        end

      end

    end

  end

  return tests

end

---@param bufnr number

---@param cursor_line number

---@param adapter utest.Adapter

---@return utest.Test|nil

function H.find_nearest_test(bufnr, cursor_line, adapter)

  local tests = H.find_tests(bufnr, adapter)

  if #tests == 0 then return nil end

  local nearest = nil

  local nearest_distance = math.huge

  for _, test in ipairs(tests) do

    if cursor_line >= test.line and cursor_line <= test.end_line then

      -- prefer the innermost test (subtest)

      if not nearest or test.line > nearest.line then nearest = test end

    elseif cursor_line >= test.line then

      local distance = cursor_line - test.line

      if distance < nearest_distance then

        nearest = test

        nearest_distance = distance

      end

    end

  end

  return nearest

end

return utest