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

mod common;

use common::{eval_lua_local, run_lua_local};

#[tokio::test]
async fn test_async_spawn_basic() {
    let script = r#"
        local handle = async.spawn(function()
            return 42
        end)
        local result = handle.await()
        assert.eq(result[1], 42)
    "#;
    run_lua_local(script).await.unwrap();
}

#[tokio::test]
async fn test_async_spawn_with_sleep() {
    let script = r#"
        local handle = async.spawn(function()
            sleep(0.01)
            return "done"
        end)
        local result = handle.await()
        assert.eq(result[1], "done")
    "#;
    run_lua_local(script).await.unwrap();
}

#[tokio::test]
async fn test_async_spawn_multiple() {
    let script = r#"
        local h1 = async.spawn(function() return 1 end)
        local h2 = async.spawn(function() return 2 end)
        local h3 = async.spawn(function() return 3 end)
        local r1 = h1.await()
        local r2 = h2.await()
        local r3 = h3.await()
        assert.eq(r1[1], 1)
        assert.eq(r2[1], 2)
        assert.eq(r3[1], 3)
    "#;
    run_lua_local(script).await.unwrap();
}

#[tokio::test]
async fn test_async_spawn_error_propagation() {
    let result = run_lua_local(
        r#"
        local handle = async.spawn(function()
            error("task failed")
        end)
        handle.await()
    "#,
    )
    .await;
    assert!(result.is_err());
    let err_msg = result.unwrap_err().to_string();
    assert!(err_msg.contains("task failed"), "got: {err_msg}");
}

#[tokio::test]
async fn test_async_spawn_double_await_errors() {
    let result = run_lua_local(
        r#"
        local handle = async.spawn(function() return 1 end)
        handle.await()
        handle.await()
    "#,
    )
    .await;
    assert!(result.is_err());
    let err_msg = result.unwrap_err().to_string();
    assert!(err_msg.contains("already awaited"), "got: {err_msg}");
}

#[tokio::test]
async fn test_async_spawn_concurrent_execution() {
    let result: bool = eval_lua_local(
        r#"
        local start = time()
        local h1 = async.spawn(function() sleep(0.05) end)
        local h2 = async.spawn(function() sleep(0.05) end)
        h1.await()
        h2.await()
        local elapsed = time() - start
        return elapsed < 0.15
    "#,
    )
    .await;
    assert!(result, "concurrent spawns should run in parallel");
}

#[tokio::test]
async fn test_async_spawn_interval_basic() {
    let script = r#"
        local count = 0
        local handle = async.spawn_interval(0.02, function()
            count = count + 1
        end)
        sleep(0.09)
        handle.cancel()
        assert.gt(count, 1)
    "#;
    run_lua_local(script).await.unwrap();
}

#[tokio::test]
async fn test_async_spawn_interval_cancel() {
    let script = r#"
        local count = 0
        local handle = async.spawn_interval(0.02, function()
            count = count + 1
        end)
        sleep(0.05)
        handle.cancel()
        local count_at_cancel = count
        sleep(0.05)
        assert.eq(count, count_at_cancel)
    "#;
    run_lua_local(script).await.unwrap();
}

#[tokio::test]
async fn test_async_spawn_interval_invalid_seconds() {
    let result = run_lua_local(r#"async.spawn_interval(0, function() end)"#).await;
    assert!(result.is_err());
    let result2 = run_lua_local(r#"async.spawn_interval(-1, function() end)"#).await;
    assert!(result2.is_err());
}