apcore 0.22.0

Schema-driven module standard for AI-perceivable interfaces
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

// Issue #43 §1: StorageBackend trait + InMemoryStorageBackend default.
//
// Verifies:
//   - InMemoryStorageBackend implements save/get/list/delete correctly.
//   - Namespaces are isolated (writes to one namespace are invisible to another).
//   - delete is idempotent (deleting an absent key is a no-op).
//   - list filters by prefix when provided.
//   - ErrorHistory accepts an optional StorageBackend at construction.

use apcore::observability::storage::{InMemoryStorageBackend, StorageBackend};
use apcore::observability::ErrorHistory;
use serde_json::json;
use std::sync::Arc;

#[tokio::test]
async fn save_and_get_roundtrips_value() {
    let backend = InMemoryStorageBackend::new();
    backend
        .save("ns", "k1", json!({"a": 1}))
        .await
        .expect("save ok");
    let v = backend.get("ns", "k1").await.expect("get ok");
    assert_eq!(v, Some(json!({"a": 1})));
}

#[tokio::test]
async fn get_missing_returns_none() {
    let backend = InMemoryStorageBackend::new();
    let v = backend.get("ns", "missing").await.expect("get ok");
    assert_eq!(v, None);
}

#[tokio::test]
async fn namespaces_are_isolated() {
    let backend = InMemoryStorageBackend::new();
    backend.save("ns_a", "k", json!(1)).await.unwrap();
    backend.save("ns_b", "k", json!(2)).await.unwrap();
    assert_eq!(backend.get("ns_a", "k").await.unwrap(), Some(json!(1)));
    assert_eq!(backend.get("ns_b", "k").await.unwrap(), Some(json!(2)));
}

#[tokio::test]
async fn list_filters_by_prefix() {
    let backend = InMemoryStorageBackend::new();
    backend.save("ns", "user/1", json!("a")).await.unwrap();
    backend.save("ns", "user/2", json!("b")).await.unwrap();
    backend.save("ns", "post/1", json!("c")).await.unwrap();
    let mut entries = backend.list("ns", "user/").await.unwrap();
    entries.sort_by(|x, y| x.0.cmp(&y.0));
    assert_eq!(entries.len(), 2);
    assert_eq!(entries[0].0, "user/1");
    assert_eq!(entries[1].0, "user/2");
}

#[tokio::test]
async fn list_with_empty_prefix_returns_all() {
    let backend = InMemoryStorageBackend::new();
    backend.save("ns", "a", json!(1)).await.unwrap();
    backend.save("ns", "b", json!(2)).await.unwrap();
    let entries = backend.list("ns", "").await.unwrap();
    assert_eq!(entries.len(), 2);
}

#[tokio::test]
async fn delete_is_idempotent() {
    let backend = InMemoryStorageBackend::new();
    // delete absent key — should not error
    backend.delete("ns", "missing").await.expect("idempotent");
    backend.save("ns", "k", json!(1)).await.unwrap();
    backend.delete("ns", "k").await.unwrap();
    assert_eq!(backend.get("ns", "k").await.unwrap(), None);
    // delete again — still ok
    backend.delete("ns", "k").await.unwrap();
}

#[tokio::test]
async fn error_history_accepts_optional_storage_backend() {
    // Constructor MUST allow passing an Option<Arc<dyn StorageBackend>>.
    let backend: Arc<dyn StorageBackend> = Arc::new(InMemoryStorageBackend::new());
    let _history = ErrorHistory::with_storage_backend(50, 1000, Some(backend));
}

#[tokio::test]
async fn error_history_accepts_none_storage_backend() {
    let _history = ErrorHistory::with_storage_backend(50, 1000, None);
}