local M = {}

local uv = vim.uv or vim.loop

---Recursively copy a directory

---@param src string

---@param dest string

local function copy_dir(src, dest)

vim.fn.mkdir(dest, 'p')

for name, type in vim.fs.dir(src) do

local src_path = src .. '/' .. name

local dest_path = dest .. '/' .. name

if type == 'directory' then

copy_dir(src_path, dest_path)

else

assert(uv.fs_copyfile(src_path, dest_path), 'failed to copy ' .. src_path)

end

end

end

---Copy a fixture project to a temp dir (outside the repo so root markers

---resolve to the fixture, not the plugin repo) and cd into it

---@param fixture string fixture dir name under tests/fixtures

---@return string project_root absolute path of the copied project

function M.open(fixture)

local src = vim.fn.fnamemodify('tests/fixtures/' .. fixture, ':p')

local dest = vim.fn.tempname() .. '-' .. fixture

copy_dir(src, dest)

vim.cmd.cd(dest)

return dest

end

---Wait until cond() is truthy or fail the test

---@param cond fun(): any

---@param timeout number ms

---@param msg string

function M.wait_for(cond, timeout, msg)

local ok = vim.wait(timeout, function()

return cond() and true or false

end, 200)

if not ok then

error(string.format('timed out after %dms waiting for: %s', timeout, msg))

end

end

---Run a workspace command on the client and wait for the response

---@param client vim.lsp.Client

---@param command string

---@param arguments? any[]

---@param timeout? number ms

---@return any # command result or nil on error/timeout

function M.execute_command(client, command, arguments, timeout)

local done = false

local cmd_result

client:request('workspace/executeCommand', {

command = command,

arguments = arguments,

}, function(err, result)

done = true

if not err then

cmd_result = result

end

end)

vim.wait(timeout or 10000, function()

return done

end, 100)

return cmd_result

end

---Wait until the project is imported by polling main class resolution

---@param client vim.lsp.Client

---@param timeout number ms

---@return table[] # resolved main classes

function M.wait_for_import(client, timeout)

local deadline = uv.now() + timeout

while uv.now() < deadline do

local result = M.execute_command(client, 'vscode.java.resolveMainClass')

if result and #result > 0 then

return result

end

vim.wait(2000)

end

error(string.format('project import did not complete within %dms', timeout))

end

---Collect leaf nodes from a test result tree

---@param results java-test.TestResults[]

---@return java-test.TestResults[]

function M.leaf_results(results)

local leaves = {}

local function walk(nodes)

for _, node in ipairs(nodes) do

if node.children and #node.children > 0 then

walk(node.children)

else

table.insert(leaves, node)

end

end

end

walk(results)

return leaves

end

---Get leaf results of the last test report, or nil if not available yet

---@return java-test.TestResults[] | nil

function M.last_report_leaves()

local last_report = require('java-test').last_report

if not last_report then

return nil

end

local ok, results = pcall(function()

return last_report:get_results()

end)

if not ok or not results then

return nil

end

return M.leaf_results(results)

end

---Check all given leaves finished execution and passed

---Note: the result parser only sets status for Failed/Skipped tests;

---a passed test ends execution with no status

---@param leaves java-test.TestResults[]

---@param count number expected leaf count

---@return boolean

function M.all_passed(leaves, count)

local execution_status = require('java-test.results.execution-status')

if #leaves ~= count then

return false

end

for _, leaf in ipairs(leaves) do

if not leaf.result or leaf.result.execution ~= execution_status.Ended then

return false

end

if leaf.result.status ~= nil then

return false

end

end

return true

end

return M