test: add headless test framework

test/init.lua

@@ -0,0 +1,147 @@
+local M = {}
+
+local stats = { passed = 0, failed = 0, errors = {} }
+local defers = {}
+local label = "?"
+local started = false
+
+local color_on = vim.env.TEST_COLOR == "1"
+
+local function color(code, str)
+    if color_on then
+        return string.format("\27[%sm%s\27[0m", code, str)
+    end
+    return str
+end
+local function red(s)
+    return color("31", s)
+end
+local function green(s)
+    return color("32", s)
+end
+
+local function ensure_started()
+    if started then
+        return
+    end
+    started = true
+    io.stdout:write(string.format("-> %s ", label))
+    io.stdout:flush()
+end
+
+---Begin a new test file. Resets per-file stats and the cleanup queue
+---and stages the per-file header for the next `M.test` call.
+---@param path string
+function M.start_file(path)
+    label = path
+    started = false
+    stats = { passed = 0, failed = 0, errors = {} }
+    defers = {}
+end
+
+---Print the per-file summary and return the counts so the runner can
+---accumulate totals across files.
+---@return integer passed
+---@return integer failed
+function M.report()
+    ensure_started()
+    if stats.failed > 0 then
+        io.stdout:write(" " .. red("FAIL") .. "\n")
+        for _, e in ipairs(stats.errors) do
+            io.stdout:write(
+                string.format(
+                    "    %s %s\n      %s\n",
+                    red("FAIL"),
+                    e.name,
+                    e.err
+                )
+            )
+        end
+    else
+        io.stdout:write(" " .. green("OK") .. "\n")
+    end
+    return stats.passed, stats.failed
+end
+
+---Queue a function to run when the current `M.test` completes (whether
+---it passed or failed). Deferred calls run in LIFO order.
+---@param fn fun()
+function M.defer(fn)
+    table.insert(defers, fn)
+end
+
+---@param name string
+---@param fn fun()
+function M.test(name, fn)
+    ensure_started()
+    local saved_cwd = vim.fn.getcwd()
+    local ok, err = pcall(fn)
+    while #defers > 0 do
+        pcall(table.remove(defers))
+    end
+    if vim.fn.getcwd() ~= saved_cwd then
+        pcall(vim.cmd.cd, saved_cwd)
+    end
+    if ok then
+        stats.passed = stats.passed + 1
+        io.stdout:write(".")
+    else
+        stats.failed = stats.failed + 1
+        table.insert(stats.errors, { name = name, err = err })
+        io.stdout:write(red("F"))
+    end
+    io.stdout:flush()
+end
+
+local function fmt_value(v)
+    if type(v) == "string" then
+        return string.format("%q", v)
+    end
+    return vim.inspect(v)
+end
+
+---@param actual any
+---@param expected any
+---@param msg string?
+function M.eq(actual, expected, msg)
+    if not vim.deep_equal(actual, expected) then
+        error(
+            string.format(
+                "%s\n  expected: %s\n  actual:   %s",
+                msg or "values differ",
+                fmt_value(expected),
+                fmt_value(actual)
+            ),
+            2
+        )
+    end
+end
+
+---@param val any
+---@param msg string?
+function M.truthy(val, msg)
+    if not val then
+        error(msg or ("expected truthy, got " .. tostring(val)), 2)
+    end
+end
+
+---@param val any
+---@param msg string?
+function M.falsy(val, msg)
+    if val then
+        error(msg or ("expected falsy, got " .. tostring(val)), 2)
+    end
+end
+
+---@param dir string
+---@param path string
+---@param content string
+function M.write(dir, path, content)
+    local full = vim.fs.joinpath(dir, path)
+    vim.fn.mkdir(vim.fs.dirname(full), "p")
+    local f = assert(io.open(full --[[@as string]], "w"))
+    f:write(content)
+    f:close()
+end
+
+return M