auditlog 0.1.0

Audit trail for your data models — an ORM-agnostic core with a pluggable, async sqlx backend (SQLite & Postgres).
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

//! Tests for *process-global* configuration: the master auditing switch and the global
//! `max_audits`. These mutate shared statics, so they live in their own test binary (separate
//! process from `behavior.rs`) and run as a single serial function to avoid intra-file races.

use auditlog::{
    AuditId, AuditOptions, Auditable, SqlxBackend, ValueMap, config, set_auditing_enabled,
    with_auditing,
};
use serde_json::json;

struct GUser {
    id: i64,
    name: String,
    status: i64,
}

impl Auditable for GUser {
    fn auditable_type() -> &'static str {
        "GUser"
    }
    fn auditable_id(&self) -> AuditId {
        self.id.into()
    }
    fn audited_attributes(&self) -> ValueMap {
        let mut m = ValueMap::new();
        m.insert("id".into(), json!(self.id));
        m.insert("name".into(), json!(self.name));
        m.insert("status".into(), json!(self.status));
        m
    }
    fn audit_options() -> AuditOptions {
        AuditOptions::default()
    }
}

async fn backend() -> SqlxBackend {
    let b = SqlxBackend::connect_sqlite("sqlite::memory:")
        .await
        .unwrap();
    b.migrate().await.unwrap();
    b
}

#[tokio::test]
async fn process_global_state() {
    // ---- global master switch ----
    {
        let b = backend().await;
        let u = GUser {
            id: 1,
            name: "A".into(),
            status: 0,
        };

        set_auditing_enabled(false);
        assert!(u.audited_create(&b).await.unwrap().is_none());

        // with_auditing must NOT re-enable when the global master switch is off
        with_auditing(async { u.audited_create(&b).await })
            .await
            .unwrap();
        assert_eq!(GUser::audits(&b, 1).await.unwrap().len(), 0);

        set_auditing_enabled(true);
        assert!(u.audited_create(&b).await.unwrap().is_some());
        assert_eq!(GUser::audits(&b, 1).await.unwrap().len(), 1);
    }

    // ---- global max_audits ----
    {
        let b = backend().await;
        config(|c| c.max_audits = Some(2));

        let mut u = GUser {
            id: 2,
            name: "Foobar".into(),
            status: 0,
        };
        u.audited_create(&b).await.unwrap(); // v1
        let o1 = GUser {
            id: 2,
            name: "Foobar".into(),
            status: 0,
        };
        u.name = "Awesome".into();
        u.audited_update(&b, &o1).await.unwrap(); // v2
        let o2 = GUser {
            id: 2,
            name: "Awesome".into(),
            status: 0,
        };
        u.status = 5;
        u.audited_update(&b, &o2).await.unwrap(); // v3

        let audits = GUser::audits(&b, 2).await.unwrap();
        assert_eq!(audits.len(), 2);
        assert_eq!(
            audits.iter().map(|a| a.version).collect::<Vec<_>>(),
            vec![2, 3]
        );

        // reset for any later tests / other runs in this process
        config(|c| c.max_audits = None);
    }
}