liminal-server 0.27.3

Standalone server for the liminal messaging bus
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

//! ACCESS-011 R3: the access answer's exact fields for the three shapes of
//! exchange, and their one-line words.

use super::AccessHealth;
use crate::config::types::{AuthConfig, Decisions, OpenConfig, Reach, ServerConfig};

type TestResult = Result<(), Box<dyn std::error::Error>>;

fn open(reach: Option<Reach>) -> Result<ServerConfig, Box<dyn std::error::Error>> {
    let mut config: ServerConfig = toml::from_str(
        "listen_address = \"127.0.0.1:7900\"\nhealth_listen_address = \"127.0.0.1:7901\"\n\
         drain_timeout_ms = 5000\nchannels = []\nrouting_rules = []\n",
    )?;
    config.open = reach.map(|reach| OpenConfig { reach });
    Ok(config)
}

fn gated(lys: Option<Decisions>) -> Result<ServerConfig, Box<dyn std::error::Error>> {
    let lys = lys.map_or(String::new(), |decisions| {
        format!(
            "[lys]\nissuer = \"https://lys.test\"\nnetwork_id = \"n\"\nkeys_path = \"/k\"\n\
             decisions = \"{decisions}\"\n"
        )
    });
    let mut config = open(None)?;
    let auth: AuthConfig = toml::from_str(&format!("token = \"s3cr3t\"\n{lys}"))?;
    config.auth = Some(auth);
    Ok(config)
}

#[test]
fn an_open_exchange_names_its_mode_and_reach() -> TestResult {
    for (reach, word) in [
        (None, "loopback"),
        (Some(Reach::Loopback), "loopback"),
        (Some(Reach::Network), "network"),
    ] {
        let access = AccessHealth::from(&open(reach)?);
        assert_eq!(
            access,
            AccessHealth {
                mode: "open",
                reach: Some(word),
                decisions: None,
            }
        );
        assert_eq!(
            serde_json::to_value(access)?,
            serde_json::json!({"mode": "open", "reach": word})
        );
        assert_eq!(access.words(), format!("mode open, reach {word}"));
    }
    Ok(())
}

#[test]
fn a_gated_exchange_names_its_mode_and_its_lys_decisions() -> TestResult {
    let bearer = AccessHealth::from(&gated(None)?);
    assert_eq!(
        serde_json::to_value(bearer)?,
        serde_json::json!({"mode": "gated"})
    );
    assert_eq!(bearer.words(), "mode gated");
    for (decisions, word) in [
        (Decisions::Enforce, "enforce"),
        (Decisions::Advise, "advise"),
    ] {
        let access = AccessHealth::from(&gated(Some(decisions))?);
        assert_eq!(
            serde_json::to_value(access)?,
            serde_json::json!({"mode": "gated", "decisions": word})
        );
        assert_eq!(access.words(), format!("mode gated, decisions {word}"));
    }
    Ok(())
}