Add new assertion functions: assert_lt, assert_gt, assert_le, assert_ge, assert_starts_with, assert_ends_with, assert_contains

Author: khvzak

lua/assertions.lua

@@ -25,6 +25,54 @@ function assertions.assert_ne(left, right, message)
     end
 end
 
+function assertions.assert_lt(left, right, message)
+    if not (left < right) then
+        if message ~= nil then
+            message = string.format("assertion `left < right` failed: %s", tostring(message))
+        else
+            message = "assertion `left < right` failed!"
+        end
+        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
+
+function assertions.assert_gt(left, right, message)
+    if not (left > right) then
+        if message ~= nil then
+            message = string.format("assertion `left > right` failed: %s", tostring(message))
+        else
+            message = "assertion `left > right` failed!"
+        end
+        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
+
+function assertions.assert_le(left, right, message)
+    if not (left <= right) then
+        if message ~= nil then
+            message = string.format("assertion `left <= right` failed: %s", tostring(message))
+        else
+            message = "assertion `left <= right` failed!"
+        end
+        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
+
+function assertions.assert_ge(left, right, message)
+    if not (left >= right) then
+        if message ~= nil then
+            message = string.format("assertion `left >= right` failed: %s", tostring(message))
+        else
+            message = "assertion `left >= right` failed!"
+        end
+        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
+
 function assertions.assert_match(obj, pattern, message)
     if not tostring(obj):match(pattern) then
         if message ~= nil then
@@ -102,4 +150,46 @@ function assertions.assert_same(left, right, message)
     end
 end
 
+function assertions.assert_starts_with(str, prefix, message)
+    str = tostring(str)
+    prefix = tostring(prefix)
+    if str:sub(1, #prefix) ~= prefix then
+        if message ~= nil then
+            message = string.format("assertion `str:starts_with(prefix)` failed: %s", tostring(message))
+        else
+            message = "assertion `str:starts_with(prefix)` failed!"
+        end
+        local frame_level = opts.level or 2
+        error(string.format("%s\n  prefix: %s\n     str: %s", message, prefix, str), frame_level)
+    end
+end
+
+function assertions.assert_ends_with(str, suffix, message)
+    str = tostring(str)
+    suffix = tostring(suffix)
+    if suffix ~= "" and str:sub(-#suffix) ~= suffix then
+        if message ~= nil then
+            message = string.format("assertion `str:ends_with(suffix)` failed: %s", tostring(message))
+        else
+            message = "assertion `str:ends_with(suffix)` failed!"
+        end
+        local frame_level = opts.level or 2
+        error(string.format("%s\n  suffix: %s\n     str: %s", message, suffix, str), frame_level)
+    end
+end
+
+function assertions.assert_contains(str, substr, message)
+    str = tostring(str)
+    substr = tostring(substr)
+    if not str:find(substr, 1, true) then
+        if message ~= nil then
+            message = string.format("assertion `str:contains(substr)` failed: %s", tostring(message))
+        else
+            message = "assertion `str:contains(substr)` failed!"
+        end
+        local frame_level = opts.level or 2
+        error(string.format("%s\n  substr: %s\n     str: %s", message, substr, str), frame_level)
+    end
+end
+
 return assertions

lua/testing.lua

@@ -40,6 +40,22 @@ function TestContext.assert_ne(a, b, msg)
     assertions.assert_ne(a, b, msg)
 end
 
+function TestContext.assert_lt(a, b, msg)
+    assertions.assert_lt(a, b, msg)
+end
+
+function TestContext.assert_gt(a, b, msg)
+    assertions.assert_gt(a, b, msg)
+end
+
+function TestContext.assert_le(a, b, msg)
+    assertions.assert_le(a, b, msg)
+end
+
+function TestContext.assert_ge(a, b, msg)
+    assertions.assert_ge(a, b, msg)
+end
+
 function TestContext.assert_match(a, b, msg)
     assertions.assert_match(a, b, msg)
 end
@@ -48,6 +64,18 @@ function TestContext.assert_same(a, b, msg)
     assertions.assert_same(a, b, msg)
 end
 
+function TestContext.assert_starts_with(a, b, msg)
+    assertions.assert_starts_with(a, b, msg)
+end
+
+function TestContext.assert_ends_with(a, b, msg)
+    assertions.assert_ends_with(a, b, msg)
+end
+
+function TestContext.assert_contains(a, b, msg)
+    assertions.assert_contains(a, b, msg)
+end
+
 function TestContext.assert(cond, msg)
     if not cond then
         if msg ~= nil then

src/assertions.rs

@@ -3,7 +3,7 @@ use mlua::{Lua, Result, Table};
 /// A loader for the `assertions` module.
 fn loader(lua: &Lua) -> Result<Table> {
     lua.load(include_str!("../lua/assertions.lua"))
-        .set_name("@mlua-stdlib/assertions.lua")
+        .set_name("@mlua-stdlib/lua/assertions.lua")
         .call(())
 }
 

tests/lua/assertions_tests.lua

@@ -2,8 +2,15 @@ local assertions = require("@assertions")
 
 local assert_eq = assertions.assert_eq
 local assert_ne = assertions.assert_ne
+local assert_lt = assertions.assert_lt
+local assert_gt = assertions.assert_gt
+local assert_le = assertions.assert_le
+local assert_ge = assertions.assert_ge
 local assert_match = assertions.assert_match
 local assert_same = assertions.assert_same
+local assert_starts_with = assertions.assert_starts_with
+local assert_ends_with = assertions.assert_ends_with
+local assert_contains = assertions.assert_contains
 
 testing:test("assert_eq", function()
     assert_eq(1, 1)
@@ -53,6 +60,74 @@ testing:test("assert_ne", function()
     assert(err:match(" right: nil"))
 end)
 
+testing:test("assert_lt", function()
+    assert_lt(1, 2)
+    assert_lt(-1, 0)
+
+    local ok, err = pcall(assert_lt, 1, 1)
+    assert(not ok)
+    assert(err:match("assertion `left < right` failed!"))
+    assert(err:match("  left: 1"))
+    assert(err:match(" right: 1"))
+
+    ok, err = pcall(assert_lt, 2, 1, "custom message")
+    assert(not ok)
+    assert(err:match("assertion `left < right` failed: custom message"))
+    assert(err:match("  left: 2"))
+    assert(err:match(" right: 1"))
+end)
+
+testing:test("assert_gt", function()
+    assert_gt(2, 1)
+    assert_gt(0, -1)
+
+    local ok, err = pcall(assert_gt, 1, 1)
+    assert(not ok)
+    assert(err:match("assertion `left > right` failed!"))
+    assert(err:match("  left: 1"))
+    assert(err:match(" right: 1"))
+
+    ok, err = pcall(assert_gt, 1, 2, "custom message")
+    assert(not ok)
+    assert(err:match("assertion `left > right` failed: custom message"))
+    assert(err:match("  left: 1"))
+    assert(err:match(" right: 2"))
+end)
+
+testing:test("assert_le", function()
+    assert_le(1, 2)
+    assert_le(1, 1)
+
+    local ok, err = pcall(assert_le, 2, 1)
+    assert(not ok)
+    assert(err:match("assertion `left <= right` failed!"))
+    assert(err:match("  left: 2"))
+    assert(err:match(" right: 1"))
+
+    ok, err = pcall(assert_le, 2, 1, "custom message")
+    assert(not ok)
+    assert(err:match("assertion `left <= right` failed: custom message"))
+    assert(err:match("  left: 2"))
+    assert(err:match(" right: 1"))
+end)
+
+testing:test("assert_ge", function()
+    assert_ge(2, 1)
+    assert_ge(1, 1)
+
+    local ok, err = pcall(assert_ge, 1, 2)
+    assert(not ok)
+    assert(err:match("assertion `left >= right` failed!"))
+    assert(err:match("  left: 1"))
+    assert(err:match(" right: 2"))
+
+    ok, err = pcall(assert_ge, 1, 2, "custom message")
+    assert(not ok)
+    assert(err:match("assertion `left >= right` failed: custom message"))
+    assert(err:match("  left: 1"))
+    assert(err:match(" right: 2"))
+end)
+
 testing:test("assert_match", function()
     assert_match("hello world", "hello")
     assert_match("12345", "%d+")
@@ -119,3 +194,55 @@ testing:test("assert_same", function()
     assert(err:match("  left%[1%]: table:"))
     assert(err:match(" right%[1%]: table:"))
 end)
+
+testing:test("assert_starts_with", function()
+    assert_starts_with("hello world", "hello")
+    assert_starts_with("hello world", "")
+
+    local ok, err = pcall(assert_starts_with, "hello world", "bye")
+    assert(not ok)
+    assert(err:match("assertion `str:starts_with%(prefix%)` failed!"))
+    assert(err:match("  prefix: bye"))
+    assert(err:match("     str: hello world"))
+
+    ok, err = pcall(assert_starts_with, "foo", "bar", "custom message")
+    assert(not ok)
+    assert(err:match("assertion `str:starts_with%(prefix%)` failed: custom message"))
+    assert(err:match("  prefix: bar"))
+    assert(err:match("     str: foo"))
+end)
+
+testing:test("assert_ends_with", function()
+    assert_ends_with("hello world", "world")
+    assert_ends_with("hello world", "")
+
+    local ok, err = pcall(assert_ends_with, "hello world", "bye")
+    assert(not ok)
+    assert(err:match("assertion `str:ends_with%(suffix%)` failed!"))
+    assert(err:match("  suffix: bye"))
+    assert(err:match("     str: hello world"))
+
+    ok, err = pcall(assert_ends_with, "foo", "bar", "custom message")
+    assert(not ok)
+    assert(err:match("assertion `str:ends_with%(suffix%)` failed: custom message"))
+    assert(err:match("  suffix: bar"))
+    assert(err:match("     str: foo"))
+end)
+
+testing:test("assert_contains", function()
+    assert_contains("hello world", "world")
+    assert_contains("hello world", "hello")
+    assert_contains("hello world", "o w")
+
+    local ok, err = pcall(assert_contains, "hello world", "bye")
+    assert(not ok)
+    assert(err:match("assertion `str:contains%(substr%)` failed!"))
+    assert(err:match("  substr: bye"))
+    assert(err:match("     str: hello world"))
+
+    ok, err = pcall(assert_contains, "foo", "bar", "custom message")
+    assert(not ok)
+    assert(err:match("assertion `str:contains%(substr%)` failed: custom message"))
+    assert(err:match("  substr: bar"))
+    assert(err:match("     str: foo"))
+end)

tests/lua/env_tests.lua

@@ -21,7 +21,7 @@ testing:test("set_current_dir", function(t)
     -- Verify the directory changed
     local new_dir, err2 = env.current_dir()
     t.assert_eq(err2, nil)
-    t.assert(new_dir ~= original_dir, "directory should have changed")
+    t.assert_ne(new_dir, original_dir, "directory should have changed")
 
     -- Change back to original directory
     local _, err3 = env.set_current_dir(original_dir)
@@ -40,7 +40,7 @@ testing:test("current_exe", function(t)
     t.assert(#exe > 0, "current_exe should not be empty")
     -- The executable path should be a valid path (contains forward slash on Unix systems)
     if env.FAMILY == "unix" then
-        t.assert(exe:match("/"), "executable should be a full path")
+        t.assert_contains(exe, "/", "executable should be a full path")
     end
 end)
 

tests/lua/http/headers_tests.lua

@@ -88,14 +88,14 @@ testing:test("Headers errors", function(t)
         return http.Headers.new(123)
     end)
     t.assert_eq(ok, false)
-    t.assert_match(err, "error converting Lua integer to table")
+    t.assert_contains(err, "error converting Lua integer to table")
 
     -- Invalid header name
     ok, err = pcall(function()
         headers:set("Invalid Header", "value")
     end)
     t.assert_eq(ok, false)
-    t.assert_match(err, "invalid HTTP header name")
+    t.assert_contains(err, "invalid HTTP header name")
 
     -- Invalid header value
     ok, err = pcall(function()

tests/lua/json_tests.lua

@@ -8,7 +8,7 @@ testing:test("encode", function(t)
 
     data, err = json.encode({ f = function() end })
     t.assert_eq(data, nil)
-    t.assert(err:find("cannot serialize <function>"), "unexpected error message: " .. err)
+    t.assert_contains(err, "cannot serialize <function>", "unexpected error message: " .. err)
 
     -- Relaxed mode
     data = json.encode({ f = function() end, a = 1 }, { relaxed = true })
@@ -30,7 +30,7 @@ testing:test("decode", function(t)
     -- Invalid JSON
     value, err = json.decode("{a:1}")
     t.assert_eq(value, nil)
-    t.assert(err:find("key must be a string"), "unexpected error message: " .. err)
+    t.assert_contains(err, "key must be a string", "unexpected error message: " .. err)
 
     -- No array metatable by default
     value, err = json.decode("[1,2,3]", { set_array_metatable = false })

tests/lua/net/tcp_tests.lua

@@ -40,7 +40,7 @@ testing:test("TCP connect timeout", function(t)
     -- The IP address is reserved for documentation and should be non-routable
     local stream, err = tcp.connect("203.0.113.95", 1234, { timeout = "100ms" })
     t.assert_eq(stream, nil)
-    t.assert_match(err, "deadline has elapsed")
+    t.assert_contains(err, "deadline has elapsed")
 end)
 
 testing:test("TCP read/write timeout", function(t)
@@ -59,15 +59,16 @@ testing:test("TCP read/write timeout", function(t)
     local data, read_err = stream:read(10)
     local elapsed = start:elapsed():as_secs()
     t.assert_eq(data, nil)
-    t.assert_match(read_err, "deadline has elapsed")
-    t.assert(elapsed >= 0.1, "elapsed time should be at least 100ms, got " .. tostring(elapsed))
+    t.assert_contains(read_err, "deadline has elapsed")
+    t.assert_ge(elapsed, 0.1, "elapsed time should be at least 100ms")
 
     start = time.Instant.now()
     local ok, write_err = stream:write_all(string.rep("abcdef", 100000))
     elapsed = start:elapsed():as_secs()
     t.assert_eq(ok, nil)
-    t.assert_match(write_err, "deadline has elapsed")
-    t.assert(elapsed >= 0.02 and elapsed < 0.03, "elapsed time should be at least 20ms, got " .. tostring(elapsed))
+    t.assert_contains(write_err, "deadline has elapsed")
+    t.assert_ge(elapsed, 0.02, "elapsed time should be at least 20ms")
+    t.assert_lt(elapsed, 0.03, "elapsed time should be less than 30ms")
 
     stream:shutdown()
 end)

tests/lua/net/tls_tests.lua

@@ -29,7 +29,7 @@ testing:test("TLS basic connection to external server", function(t)
     t.assert_ne(write_ok, nil, write_err)
     local data, read_err = tls_stream:read(1024)
     t.assert_ne(data, nil, read_err)
-    t.assert_match(data, "HTTP/1.1", "Should receive HTTP response")
+    t.assert_contains(data, "HTTP/1.1", "Should receive HTTP response")
 
     tls_stream:shutdown()
 end)