treetop-client 0.0.4

Typed async Rust client for Treetop policy authorization servers
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

#![cfg(feature = "server-tests")]

mod common;

use common::{alice_view_photo, ensure_policies, server};
use treetop_client::{AuthorizeRequest, Client, DecisionBrief};

// The live treetop-rest container does not expose received correlation IDs in
// responses or metrics. Exact header propagation is asserted in wiremock tests;
// these server tests are smoke tests that prove correlation IDs are accepted
// end-to-end without changing behavior.

#[tokio::test]
async fn correlation_id_health_smoke() {
    let s = server().await;
    s.client()
        .with_correlation_id("test-corr-123")
        .unwrap()
        .health()
        .await
        .unwrap();
}

#[tokio::test]
async fn correlation_id_does_not_change_decision() {
    let s = server().await;
    ensure_policies(s).await;

    let request = alice_view_photo();
    let without = s.client().is_allowed(request.clone()).await.unwrap();
    let with = s
        .client()
        .with_correlation_id("corr-id")
        .unwrap()
        .is_allowed(request)
        .await
        .unwrap();

    assert_eq!(
        without, with,
        "correlation ID should not affect authorization decision"
    );
}

#[tokio::test]
async fn without_correlation_id_works() {
    let s = server().await;
    let client = s
        .client()
        .with_correlation_id("temp")
        .unwrap()
        .without_correlation_id();
    client.health().await.unwrap();
}

#[tokio::test]
async fn correlation_id_builder_smoke_across_endpoints() {
    let s = server().await;
    ensure_policies(s).await;

    let client = Client::builder(&s.base_url)
        .correlation_id("builder-corr")
        .build()
        .unwrap();

    client.health().await.unwrap();
    let _version = client.version().await.unwrap();

    let batch = AuthorizeRequest::single(alice_view_photo());
    let resp = client.authorize(&batch).await.unwrap();
    assert_eq!(resp.successes(), 1);
    match &resp.results()[0].result {
        treetop_client::BatchResult::Success { data } => {
            assert_eq!(data.decision, DecisionBrief::Allow);
        }
        _ => panic!("expected success"),
    }
}