Add simple testing framework

Author: khvzak

Cargo.toml

@@ -16,6 +16,4 @@ luau = ["mlua/luau"]
 
 [dependencies]
 mlua = { version = "0.11" }
-
-[dev-dependencies]
-mlua = { version = "0.11", features = ["macros"] }
+owo-colors = "4"

lua/assertions.lua

@@ -1,3 +1,4 @@
+local opts = ... or {}
 local assertions = {}
 
 function assertions.assert_eq(left, right, message)
@@ -7,7 +8,8 @@ function assertions.assert_eq(left, right, message)
         else
             message = "assertion `left == right` failed!"
         end
-        error(string.format("%s\n  left: %s\n right: %s", message, tostring(left), tostring(right)))
+        local frame_level = opts.level or 2
+        error(string.format("%s\n  left: %s\n right: %s", message, tostring(left), tostring(right)), frame_level)
     end
 end
 
@@ -18,7 +20,8 @@ function assertions.assert_ne(left, right, message)
         else
             message = "assertion `left ~= right` failed!"
         end
-        error(string.format("%s\n  left: %s\n right: %s", message, tostring(left), tostring(right)))
+        local frame_level = opts.level or 2
+        error(string.format("%s\n  left: %s\n right: %s", message, tostring(left), tostring(right)), frame_level)
     end
 end
 
@@ -80,9 +83,10 @@ function assertions.assert_same(left, right, message)
         else
             message = "assertion `left ~ right` failed!"
         end
-        error(
+        local error_msg =
             string.format("%s\n  left%s: %s\n right%s: %s", message, level, tostring(left_v), level, tostring(right_v))
-        )
+        local frame_level = opts.level or 2
+        error(error_msg, frame_level)
     end
 end
 

lua/testing.lua

@@ -0,0 +1,225 @@
+local deps = ...
+local assertions = deps.assertions
+
+local println, style = deps.println, deps.style
+local instant = deps.instant
+
+local Testing = {}
+Testing.__index = Testing
+
+function Testing.new(name)
+    local self = setmetatable({}, Testing)
+    self._name = name
+    self._tests = {}
+    self._hooks = {
+        before_all = {},
+        after_all = {},
+        before_each = {},
+        after_each = {},
+    }
+    self._results = {}
+    return self
+end
+
+-- Test context passed to each test function
+local TestContext = {}
+TestContext.__index = TestContext
+
+function TestContext.new(name)
+    local self = setmetatable({}, TestContext)
+    self.name = name
+    return self
+end
+
+-- Forward assertion methods to the assertions module
+function TestContext.assert_eq(a, b, msg)
+    assertions.assert_eq(a, b, msg)
+end
+
+function TestContext.assert_same(a, b, msg)
+    assertions.assert_same(a, b, msg)
+end
+
+function TestContext.assert(cond, msg)
+    if not cond then
+        if msg ~= nil then
+            error("assertion failed: " .. tostring(msg), 2)
+        else
+            error("assertion failed!", 2)
+        end
+    end
+end
+
+-- Add convenience methods
+function TestContext.skip(reason)
+    error("__SKIP__: " .. (reason or "skipped"), 0)
+end
+
+-- Hooks registration
+function Testing:before_all(func)
+    table.insert(self._hooks.before_all, func)
+end
+
+function Testing:after_all(func)
+    table.insert(self._hooks.after_all, func)
+end
+
+function Testing:before_each(func)
+    table.insert(self._hooks.before_each, func)
+end
+
+function Testing:after_each(func)
+    table.insert(self._hooks.after_each, func)
+end
+
+-- Tests registration
+function Testing:test(name, func)
+    table.insert(self._tests, { name = name, func = func })
+end
+
+-- Run a single test
+function Testing:_run_single_test(test)
+    local ctx = TestContext.new(test.name)
+    local start_time = instant()
+    local success, err = true, nil
+
+    -- Run before_each hooks
+    for _, func in ipairs(self._hooks.before_each) do
+        local ok, hook_err = pcall(func)
+        if not ok then
+            return {
+                name = test.name,
+                passed = false,
+                skipped = false,
+                error = "before_each failed: " .. tostring(hook_err),
+                duration = start_time:elapsed(),
+            }
+        end
+    end
+
+    -- Run the test
+    local test_ok, test_err = pcall(test.func, ctx)
+    if not test_ok then
+        if test_err and test_err:match("^__SKIP__:") then
+            success, err = "skip", test_err:match("^__SKIP__: (.*)")
+        else
+            success, err = false, test_err
+        end
+    end
+
+    -- Run after_each hooks (even if test failed)
+    for _, func in ipairs(self._hooks.after_each) do
+        local ok, hook_err = pcall(func)
+        if not ok then
+            return {
+                name = test.name,
+                passed = false,
+                skipped = false,
+                error = "after_each failed: " .. tostring(hook_err),
+                duration = start_time:elapsed(),
+            }
+        end
+    end
+
+    return {
+        name = test.name,
+        passed = success == true,
+        skipped = success == "skip",
+        error = err,
+        duration = start_time:elapsed(),
+    }
+end
+
+-- Run all tests
+function Testing:run(opts)
+    opts = opts or {}
+    local pattern = opts.pattern
+    self._results = {}
+    local start_time = instant()
+
+    -- Run before_all hooks
+    for _, func in ipairs(self._hooks.before_all) do
+        func()
+    end
+
+    -- Run tests
+    for _, test in ipairs(self._tests) do
+        if not pattern or test.name:find(pattern) then
+            local result = self:_run_single_test(test)
+            table.insert(self._results, result)
+        end
+    end
+
+    -- Run after_all hooks
+    for _, func in ipairs(self._hooks.after_all) do
+        func()
+    end
+
+    self._results.duration = start_time:elapsed()
+
+    -- Print results unless quiet
+    if not opts.quiet then
+        self:_print_results()
+    end
+
+    -- Return success status
+    local failed = 0
+    for _, result in ipairs(self._results) do
+        if not result.passed and not result.skipped then
+            failed = failed + 1
+        end
+    end
+
+    return failed == 0, self._results
+end
+
+function Testing:_print_results()
+    local passed, failed, skipped = 0, 0, 0
+
+    for _, result in ipairs(self._results) do
+        local status = style(result.passed and "✓" or (result.skipped and "⊝" or "✗"))
+        status:color(result.passed and "green" or (result.skipped and "yellow" or "red"))
+
+        println(status, result.name)
+        if result.error then
+            println(tostring(result.error))
+        end
+
+        if result.passed then
+            passed = passed + 1
+        elseif result.skipped then
+            skipped = skipped + 1
+        else
+            failed = failed + 1
+        end
+    end
+
+    local total = passed + failed + skipped
+    if total == 0 then
+        -- No tests were run
+        return
+    end
+
+    local prefix = "test results:"
+    if self._name then
+        prefix = string.format("`%s` %s", self._name, prefix)
+    end
+    local duration = self._results.duration
+    local stats = string.format(
+        "%d passed, %d failed, %d skipped (%d total finished in %s)",
+        passed,
+        failed,
+        skipped,
+        total,
+        duration
+    )
+    println()
+    println(prefix, stats)
+end
+
+-- Get results for the Rust integration
+function Testing:results()
+    return self._results
+end
+
+return Testing

src/assertions.rs

@@ -1,14 +1,16 @@
 use mlua::{Lua, Result, Table};
 
 /// A loader for the `assertions` module.
-pub fn loader(lua: &Lua, name: String) -> Result<Table> {
+fn loader(lua: &Lua) -> Result<Table> {
     lua.load(include_str!("../lua/assertions.lua"))
-        .set_name(format!("={name}"))
+        .set_name(format!("@mlua-stdlib/assertions.lua"))
         .call(())
 }
 
 /// Registers the `assertions` module in the given Lua state.
-pub fn register(lua: &Lua, name: Option<&str>) -> Result<()> {
+pub fn register(lua: &Lua, name: Option<&str>) -> Result<Table> {
     let name = name.unwrap_or("@assertions");
-    lua.register_module(name, loader(lua, name.to_string())?)
+    let value = loader(lua)?;
+    lua.register_module(name, &value)?;
+    Ok(value)
 }

src/lib.rs

@@ -1 +1,5 @@
+pub(crate) mod terminal;
+pub(crate) mod time;
+
 pub mod assertions;
+pub mod testing;

src/terminal.rs

@@ -0,0 +1,85 @@
+use std::fmt;
+
+use mlua::{
+    AnyUserData, Lua, MetaMethod, MultiValue, Result, UserData, UserDataMethods, UserDataRegistry, Value,
+};
+use owo_colors::{AnsiColors, DynColor};
+
+pub(crate) struct Style {
+    text: String,
+    style: owo_colors::Style,
+}
+
+impl UserData for Style {
+    fn register(registry: &mut UserDataRegistry<Self>) {
+        // Sets the color for the text
+        registry.add_function("color", |_, (ud, color): (AnyUserData, String)| {
+            let mut this = ud.borrow_mut::<Self>()?;
+            this.style = this.style.color(str2color(&color));
+            Ok(ud)
+        });
+
+        // Sets the background color for the text
+        registry.add_function("on", |_, (ud, color): (AnyUserData, String)| {
+            let mut this = ud.borrow_mut::<Self>()?;
+            this.style = this.style.on_color(str2color(&color));
+            Ok(ud)
+        });
+
+        registry.add_meta_method(MetaMethod::ToString, |_, this, ()| Ok(format!("{this}")));
+    }
+}
+
+impl fmt::Display for Style {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.style.style(&self.text).fmt(f)
+    }
+}
+
+pub(crate) fn style(_: &Lua, value: Value) -> Result<Style> {
+    let text = value.to_string()?;
+    Ok(Style {
+        text,
+        style: owo_colors::Style::new(),
+    })
+}
+
+pub(crate) fn print(_: &Lua, values: MultiValue) -> Result<()> {
+    let mut first = true;
+    for value in values {
+        if !first {
+            print!(" ");
+        }
+        first = false;
+        print!("{}", value.to_string()?);
+    }
+    Ok(())
+}
+
+pub(crate) fn println(lua: &Lua, values: MultiValue) -> Result<()> {
+    print(lua, values)?;
+    println!();
+    Ok(())
+}
+
+fn str2color(s: &str) -> impl DynColor {
+    match s.to_ascii_lowercase().as_str() {
+        "black" => AnsiColors::Black,
+        "red" => AnsiColors::Red,
+        "green" => AnsiColors::Green,
+        "yellow" => AnsiColors::Yellow,
+        "blue" => AnsiColors::Blue,
+        "magenta" => AnsiColors::Magenta,
+        "cyan" => AnsiColors::Cyan,
+        "white" => AnsiColors::White,
+        "bright_black" => AnsiColors::BrightBlack,
+        "bright_red" => AnsiColors::BrightRed,
+        "bright_green" => AnsiColors::BrightGreen,
+        "bright_yellow" => AnsiColors::BrightYellow,
+        "bright_blue" => AnsiColors::BrightBlue,
+        "bright_magenta" => AnsiColors::BrightMagenta,
+        "bright_cyan" => AnsiColors::BrightCyan,
+        "bright_white" => AnsiColors::BrightWhite,
+        _ => AnsiColors::Default,
+    }
+}