assay-lua 0.10.3

General-purpose enhanced Lua runtime. Batteries-included scripting, automation, and web services.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

mod common;

use common::run_lua_with_lib_path;

fn setup_lib_dir(name: &str) -> std::path::PathBuf {
    let dir = std::env::temp_dir().join(format!("assay_test_{name}"));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    dir
}

fn cleanup(dir: &std::path::Path) {
    let _ = std::fs::remove_dir_all(dir);
}

#[tokio::test]
async fn test_fs_require_loads_external_module() {
    let dir = setup_lib_dir("fs_require_basic");
    std::fs::write(
        dir.join("mylib.lua"),
        "local M = {}\nfunction M.hello() return \"world\" end\nreturn M\n",
    )
    .unwrap();

    let script = r#"
        local mylib = require("assay.mylib")
        assert.eq(mylib.hello(), "world")
    "#;
    let result = run_lua_with_lib_path(script, dir.to_str().unwrap()).await;
    cleanup(&dir);
    result.unwrap();
}

#[tokio::test]
async fn test_fs_require_filesystem_takes_priority() {
    let dir = setup_lib_dir("fs_require_priority");
    std::fs::write(
        dir.join("vault.lua"),
        "local M = {}\nfunction M.custom() return \"filesystem vault\" end\nreturn M\n",
    )
    .unwrap();

    let script = r#"
        local vault = require("assay.vault")
        assert.not_nil(vault)
        assert.eq(vault.custom(), "filesystem vault")
    "#;
    let result = run_lua_with_lib_path(script, dir.to_str().unwrap()).await;
    cleanup(&dir);
    result.unwrap();
}

#[tokio::test]
async fn test_fs_require_nonexistent_module_errors() {
    let dir = setup_lib_dir("fs_require_missing");

    let script = r#"
        local missing = require("assay.does_not_exist")
    "#;
    let result = run_lua_with_lib_path(script, dir.to_str().unwrap()).await;
    cleanup(&dir);
    assert!(result.is_err(), "requiring nonexistent module should error");
}

#[tokio::test]
async fn test_fs_require_module_has_access_to_builtins() {
    let dir = setup_lib_dir("fs_require_builtins");
    std::fs::write(
        dir.join("checker.lua"),
        r#"
local M = {}
function M.check_url(url)
    local resp = http.get(url)
    return resp.status
end
return M
"#,
    )
    .unwrap();

    let script = r#"
        local checker = require("assay.checker")
        assert.not_nil(checker)
        assert.not_nil(checker.check_url)
    "#;
    let result = run_lua_with_lib_path(script, dir.to_str().unwrap()).await;
    cleanup(&dir);
    result.unwrap();
}

#[tokio::test]
async fn test_fs_require_module_can_require_embedded() {
    let dir = setup_lib_dir("fs_require_chain");
    std::fs::write(
        dir.join("wrapper.lua"),
        r#"
local vault = require("assay.vault")
local M = {}
function M.has_vault()
    return vault ~= nil and vault.client ~= nil
end
return M
"#,
    )
    .unwrap();

    let script = r#"
        local wrapper = require("assay.wrapper")
        assert.eq(wrapper.has_vault(), true)
    "#;
    let result = run_lua_with_lib_path(script, dir.to_str().unwrap()).await;
    cleanup(&dir);
    result.unwrap();
}

#[tokio::test]
async fn test_fs_require_default_path_without_env() {
    let script = r#"
        local ok, err = pcall(require, "assay.nonexistent_lib_xyz")
        assert.eq(ok, false)
        assert.contains(tostring(err), "nonexistent_lib_xyz")
    "#;
    // Uses default /libs path (no explicit lib path override)
    common::run_lua(script).await.unwrap();
}

#[tokio::test]
async fn test_fs_require_caches_module() {
    let dir = setup_lib_dir("fs_require_cache");
    std::fs::write(
        dir.join("counter.lua"),
        "local M = { count = 0 }\nM.count = M.count + 1\nreturn M\n",
    )
    .unwrap();

    let script = r#"
        local a = require("assay.counter")
        local b = require("assay.counter")
        a.marker = "cached"
        assert.eq(b.marker, "cached", "require should return cached module (same table)")
        assert.eq(a.count, 1, "module should only execute once")
    "#;
    let result = run_lua_with_lib_path(script, dir.to_str().unwrap()).await;
    cleanup(&dir);
    result.unwrap();
}

#[tokio::test]
async fn test_fs_require_non_assay_prefix_ignored() {
    let script = r#"
        local ok, err = pcall(require, "mycompany.mylib")
        assert.eq(ok, false)
    "#;
    common::run_lua(script).await.unwrap();
}