origin-secrets 0.2.0

SecretStore contract for Origin, with an in-memory implementation and a shared contract test suite.
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

//! The contract every [`SecretStore`] implementation must satisfy (ADR-0004, ยง41).
//!
//! Adapters run this suite against their own backend, so a system keychain and the
//! in-memory double cannot drift apart:
//!
//! ```ignore
//! #[tokio::test]
//! async fn satisfies_the_secret_store_contract() {
//!     origin_secrets::contract::run_all(&MySecretStore::new(), "my-store-test").await;
//! }
//! ```

use crate::{Secret, SecretKey, SecretStore};

/// Run every contract check against `store`.
///
/// `namespace` must be unique per implementation so that parallel test runs against a
/// real system keychain do not collide.
pub async fn run_all<S: SecretStore>(store: &S, namespace: &str) {
    missing_key_returns_none(store, namespace).await;
    write_then_read(store, namespace).await;
    overwrite_replaces_the_value(store, namespace).await;
    delete_removes_the_value(store, namespace).await;
    delete_is_idempotent(store, namespace).await;
    keys_are_isolated(store, namespace).await;
    concurrent_writes_do_not_corrupt(store, namespace).await;
}

async fn missing_key_returns_none<S: SecretStore>(store: &S, namespace: &str) {
    let key = SecretKey::new(namespace, "does-not-exist");
    let _ = store.delete(&key).await;

    assert!(
        store.get(&key).await.expect("get must not fail").is_none(),
        "a missing key must yield Ok(None), not an error"
    );
}

async fn write_then_read<S: SecretStore>(store: &S, namespace: &str) {
    let key = SecretKey::new(namespace, "write-then-read");
    store.set(&key, Secret::new("value-1")).await.expect("set");

    let stored = store.get(&key).await.expect("get").expect("value present");
    assert_eq!(stored.expose(), "value-1");

    store.delete(&key).await.expect("cleanup");
}

async fn overwrite_replaces_the_value<S: SecretStore>(store: &S, namespace: &str) {
    let key = SecretKey::new(namespace, "overwrite");
    store.set(&key, Secret::new("first")).await.expect("set");
    store
        .set(&key, Secret::new("second"))
        .await
        .expect("overwrite");

    let stored = store.get(&key).await.expect("get").expect("value present");
    assert_eq!(stored.expose(), "second", "set must replace, not append");

    store.delete(&key).await.expect("cleanup");
}

async fn delete_removes_the_value<S: SecretStore>(store: &S, namespace: &str) {
    let key = SecretKey::new(namespace, "delete");
    store.set(&key, Secret::new("value")).await.expect("set");
    store.delete(&key).await.expect("delete");

    assert!(store.get(&key).await.expect("get").is_none());
}

async fn delete_is_idempotent<S: SecretStore>(store: &S, namespace: &str) {
    let key = SecretKey::new(namespace, "delete-twice");
    store.set(&key, Secret::new("value")).await.expect("set");

    store.delete(&key).await.expect("first delete");
    store
        .delete(&key)
        .await
        .expect("deleting a missing key must succeed");
}

async fn keys_are_isolated<S: SecretStore>(store: &S, namespace: &str) {
    let one = SecretKey::new(namespace, "isolated-a");
    let two = SecretKey::new(namespace, "isolated-b");

    store.set(&one, Secret::new("a")).await.expect("set a");
    store.set(&two, Secret::new("b")).await.expect("set b");

    assert_eq!(
        store.get(&one).await.expect("get a").expect("a").expose(),
        "a"
    );
    assert_eq!(
        store.get(&two).await.expect("get b").expect("b").expose(),
        "b"
    );

    store.delete(&one).await.expect("cleanup a");
    store.delete(&two).await.expect("cleanup b");
}

async fn concurrent_writes_do_not_corrupt<S: SecretStore>(store: &S, namespace: &str) {
    let key = SecretKey::new(namespace, "concurrent");

    let (first, second) = tokio::join!(
        store.set(&key, Secret::new("writer-a")),
        store.set(&key, Secret::new("writer-b"))
    );
    first.expect("concurrent set a");
    second.expect("concurrent set b");

    let stored = store.get(&key).await.expect("get").expect("value present");
    assert!(
        matches!(stored.expose(), "writer-a" | "writer-b"),
        "a concurrent write must leave one whole value, got {stored:?}"
    );

    store.delete(&key).await.expect("cleanup");
}