assay-lua 0.15.13

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

mod common;

use common::create_vm;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

#[tokio::test]
async fn test_download_writes_body_to_file() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/asset.bin"))
        .respond_with(ResponseTemplate::new(200).set_body_bytes(b"hello\n".as_slice()))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let dest = dir.path().join("out.bin");
    let url = format!("{}/asset.bin", server.uri());
    let dest_str = dest.to_str().unwrap().to_string();

    let vm = create_vm();
    vm.globals().set("u", url).unwrap();
    vm.globals().set("d", dest_str).unwrap();
    let bytes: i64 = vm
        .load(r#"return http.download(u, d)"#)
        .eval_async()
        .await
        .unwrap();
    assert_eq!(bytes, 6);
    let written = std::fs::read(&dest).unwrap();
    assert_eq!(written, b"hello\n");
}

#[tokio::test]
async fn test_download_404_errors_no_partial_file() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/missing"))
        .respond_with(ResponseTemplate::new(404))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let dest = dir.path().join("out.bin");
    let url = format!("{}/missing", server.uri());
    let dest_str = dest.to_str().unwrap().to_string();

    let vm = create_vm();
    vm.globals().set("u", url).unwrap();
    vm.globals().set("d", dest_str.clone()).unwrap();
    let result: mlua::Result<i64> = vm.load(r#"return http.download(u, d)"#).eval_async().await;
    assert!(result.is_err());
    // No partial file should exist.
    assert!(!std::path::Path::new(&dest_str).exists());
}

#[tokio::test]
async fn test_download_creates_parent_dir() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/x"))
        .respond_with(ResponseTemplate::new(200).set_body_bytes(b"x".as_slice()))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let dest = dir.path().join("nested/dirs/out.bin");
    let url = format!("{}/x", server.uri());
    let dest_str = dest.to_str().unwrap().to_string();

    let vm = create_vm();
    vm.globals().set("u", url).unwrap();
    vm.globals().set("d", dest_str).unwrap();
    let _: i64 = vm
        .load(r#"return http.download(u, d)"#)
        .eval_async()
        .await
        .unwrap();
    assert_eq!(std::fs::read(&dest).unwrap(), b"x");
}

#[tokio::test]
async fn test_download_atomic_temp_then_rename() {
    // Verify that an interrupted download doesn't leave a partial file at dest.
    // Hard to simulate mid-stream cancellation cleanly; we just verify the
    // success-path post-condition: dest exists and contains the full body.
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/big"))
        .respond_with(ResponseTemplate::new(200).set_body_bytes(vec![0xABu8; 100_000]))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let dest = dir.path().join("big.bin");
    let url = format!("{}/big", server.uri());
    let dest_str = dest.to_str().unwrap().to_string();

    let vm = create_vm();
    vm.globals().set("u", url).unwrap();
    vm.globals().set("d", dest_str).unwrap();
    let bytes: i64 = vm
        .load(r#"return http.download(u, d)"#)
        .eval_async()
        .await
        .unwrap();
    assert_eq!(bytes, 100_000);
    assert_eq!(std::fs::metadata(&dest).unwrap().len(), 100_000);
}