socle 3.0.0

Opinionated axum service bootstrap: telemetry, database, rate limiting, and shutdown in one builder
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

#![cfg(feature = "test-util")]

use std::sync::Arc;

use axum::Router;
use axum::body::Body;
use axum::extract::Extension;
use axum::http::{Request, StatusCode};
use axum::response::IntoResponse;
use axum::routing::post;
use tower::ServiceExt;

use socle::{AuditAnnotation, AuditAnnotationSlot, AuditLayer, ChannelAuditSink};

async fn create_handler(Extension(slot): Extension<AuditAnnotationSlot>) -> impl IntoResponse {
    slot.annotate(
        AuditAnnotation::default()
            .set_resource("order", "ord-1")
            .set_action("create"),
    );
    StatusCode::CREATED
}

async fn get_handler() -> impl IntoResponse {
    StatusCode::OK
}

fn build_router(sink: Arc<ChannelAuditSink>) -> Router {
    Router::new()
        .route("/orders", post(create_handler))
        .route("/orders", axum::routing::get(get_handler))
        .layer(AuditLayer::new(sink))
}

#[tokio::test]
async fn emits_one_event_per_matching_post() {
    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
    let sink = Arc::new(ChannelAuditSink::new(tx));
    let app = build_router(sink);

    let req = Request::builder()
        .method("POST")
        .uri("/orders")
        .body(Body::empty())
        .unwrap();

    let resp = app.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::CREATED);

    tokio::task::yield_now().await;

    let event = rx.try_recv().expect("one audit event expected");
    assert_eq!(event.method, "POST");
    assert_eq!(event.status, 201);
    assert_eq!(event.resource_type.as_deref(), Some("order"));
    assert_eq!(event.resource_id.as_deref(), Some("ord-1"));
    assert_eq!(event.action.as_deref(), Some("create"));
}

#[tokio::test]
async fn no_event_for_get_request() {
    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
    let sink = Arc::new(ChannelAuditSink::new(tx));
    let app = build_router(sink);

    let req = Request::builder()
        .method("GET")
        .uri("/orders")
        .body(Body::empty())
        .unwrap();

    let resp = app.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::OK);

    tokio::task::yield_now().await;

    assert!(rx.try_recv().is_err(), "GET should not emit an audit event");
}

#[tokio::test]
async fn no_event_for_healthz_path() {
    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
    let sink = Arc::new(ChannelAuditSink::new(tx));

    let app = Router::new()
        .route("/healthz", axum::routing::get(get_handler))
        .route("/healthz", post(create_handler))
        .layer(AuditLayer::new(sink));

    let req = Request::builder()
        .method("POST")
        .uri("/healthz")
        .body(Body::empty())
        .unwrap();

    let resp = app.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::CREATED);

    tokio::task::yield_now().await;

    assert!(
        rx.try_recv().is_err(),
        "POST /healthz should not emit an audit event"
    );
}

#[tokio::test]
async fn annotation_without_slot_does_not_panic() {
    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
    let sink = Arc::new(ChannelAuditSink::new(tx));

    async fn bare_handler() -> impl IntoResponse {
        StatusCode::CREATED
    }

    let app = Router::new()
        .route("/items", post(bare_handler))
        .layer(AuditLayer::new(sink));

    let req = Request::builder()
        .method("POST")
        .uri("/items")
        .body(Body::empty())
        .unwrap();

    let resp = app.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::CREATED);

    tokio::task::yield_now().await;

    let event = rx
        .try_recv()
        .expect("event expected even without annotation");
    assert!(event.resource_type.is_none());
}