assay-lua 0.17.6

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

mod common;

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

#[tokio::test]
async fn test_neutron_agents_list_sends_bearer() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/api/admin/agents"))
        .and(header("authorization", "Bearer nck_test"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "brand": "Demo",
            "agents": [{"id": "a1", "slug": "tom", "display_name": "Tom"}],
            "default_agent": {"stored": {}},
        })))
        .mount(&server)
        .await;

    let script = format!(
        r#"
        local neutron = require("assay.neutron")
        local c = neutron.client("{}", {{ token = "nck_test" }})
        local out = c.agents:list()
        assert.eq(out.brand, "Demo")
        assert.eq(#out.agents, 1)
        assert.eq(out.agents[1].slug, "tom")
        "#,
        server.uri()
    );
    run_lua(&script).await.unwrap();
}

#[tokio::test]
async fn test_neutron_secrets_set_and_list() {
    let server = MockServer::start().await;
    Mock::given(method("PUT"))
        .and(path("/api/admin/secrets/api-key"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "secrets": [{"name": "api-key", "has_value": true, "preview": "v1a2…l3"}],
        })))
        .mount(&server)
        .await;

    let script = format!(
        r#"
        local neutron = require("assay.neutron")
        local c = neutron.client("{}", {{ token = "nck_test" }})
        local secrets = c.secrets:set("api-key", {{ value = "v1a2l3", agents = {{"tom"}} }})
        assert.eq(#secrets, 1)
        assert.eq(secrets[1].has_value, true)
        "#,
        server.uri()
    );
    run_lua(&script).await.unwrap();
}

#[tokio::test]
async fn test_neutron_cf_access_headers() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/api/admin/tokens"))
        .and(header("cf-access-client-id", "cfid"))
        .and(header("cf-access-client-secret", "cfsecret"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({"tokens": []})))
        .mount(&server)
        .await;

    let script = format!(
        r#"
        local neutron = require("assay.neutron")
        local c = neutron.client("{}", {{
            token = "nck_test", cf_client_id = "cfid", cf_client_secret = "cfsecret",
        }})
        assert.eq(#c.tokens:list(), 0)
        "#,
        server.uri()
    );
    run_lua(&script).await.unwrap();
}

#[tokio::test]
async fn test_neutron_http_error_surfaces() {
    let server = MockServer::start().await;
    Mock::given(method("DELETE"))
        .and(path("/api/admin/connections/nope"))
        .respond_with(
            ResponseTemplate::new(404).set_body_json(serde_json::json!({"error": "not found"})),
        )
        .mount(&server)
        .await;

    let script = format!(
        r#"
        local neutron = require("assay.neutron")
        local c = neutron.client("{}", {{ token = "nck_test" }})
        local ok, err = pcall(function() return c.connections:delete("nope") end)
        assert.eq(ok, false)
        assert.contains(tostring(err), "HTTP 404")
        "#,
        server.uri()
    );
    run_lua(&script).await.unwrap();
}

#[tokio::test]
async fn test_neutron_client_requires_token() {
    let script = r#"
        local neutron = require("assay.neutron")
        local ok, err = pcall(function() return neutron.client("http://x.example") end)
        assert.eq(ok, false)
        assert.contains(tostring(err), "no token")
    "#;
    run_lua(script).await.unwrap();
}