liminal-server 0.23.1

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use super::fixture::{Fixture, ISSUED_AT, LIFETIME, NOW, Result};
use super::{LinkAction, LinkRights, Rights};
use crate::auth_lys::{RefusalCause, SubjectBinding};
use std::sync::atomic::Ordering;

#[derive(PartialEq, Eq)]
struct RedactedPass<'a>(&'a str);

impl std::fmt::Debug for RedactedPass<'_> {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter.write_str("<redacted pass>")
    }
}

#[test]
fn an_hour_old_importer_uses_its_renewed_pass_on_the_first_inbound_open() -> Result {
    let fixture = Fixture::new(true, false)?;
    const { assert!(NOW - ISSUED_AT > LIFETIME) };
    let result = fixture
        .session()?
        .open_link(&Fixture::link(), LinkAction::Export, NOW);
    assert!(
        result.is_ok(),
        "link_refused:{}",
        serde_json::to_string(&result.err().ok_or("no refusal")?.refusal)?
    );
    assert!(matches!(
        result?,
        crate::auth_lys::DeliberateDecision::Outright(_)
    ));
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    assert_eq!(
        RedactedPass(fixture.authority.pass.current()?.as_str()),
        RedactedPass(fixture.renewed.as_str())
    );
    let bound = SubjectBinding::link(
        "network".to_owned(),
        super::fixture::LINK.to_owned(),
        "health".to_owned(),
    )?;
    Rights(fixture.authority.clone()).holds(LinkAction::Import, &bound, NOW)?;
    fixture.finish()
}

#[test]
fn a_renewed_importer_pass_without_the_link_grant_is_refused_by_name() -> Result {
    let fixture = Fixture::new(false, false)?;
    let refused = fixture
        .authority
        .open(&Fixture::link(), LinkAction::Export, NOW)
        .err()
        .ok_or("renewed pass without grant admitted")?;
    assert_eq!(refused.refusal.refused.action, "link_import");
    assert_eq!(refused.cause.to_string(), "renewed-without-grant");
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    assert_eq!(
        RedactedPass(fixture.authority.pass.current()?.as_str()),
        RedactedPass(fixture.renewed.as_str())
    );
    fixture.finish()
}

#[test]
fn an_expired_outbound_pass_is_presented_renewed_on_the_same_open() -> Result {
    let fixture = Fixture::new(true, false)?;
    let token = fixture.authority.pass.for_open_at(NOW)?;
    assert_eq!(
        RedactedPass(token.as_str()),
        RedactedPass(fixture.renewed.as_str()),
        "open did not present the renewed token"
    );
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    fixture.finish()
}

#[test]
fn a_failed_importer_renewal_keeps_the_open_refused() -> Result {
    let fixture = Fixture::new(true, true)?;
    let refused = fixture
        .authority
        .open(&Fixture::link(), LinkAction::Export, NOW)
        .err()
        .ok_or("failed renewal admitted")?;
    assert_eq!(refused.cause, RefusalCause::DeliberateUnavailable);
    assert_eq!(refused.refusal.refused.action, "link_import");
    assert_eq!(fixture.calls.load(Ordering::Relaxed), 1);
    assert_ne!(
        RedactedPass(fixture.authority.pass.current()?.as_str()),
        RedactedPass(fixture.renewed.as_str())
    );
    fixture.finish()
}