reef-core 0.4.0

Provider-neutral primitives for building LLM agents: run lifecycle, transcript, tools, hooks
Documentation
#![cfg(test)]

use super::run_state::{self, Key, Store};
use std::collections::HashSet;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Barrier};
use std::thread;

#[test]
fn cloned_keys_share_identity_while_fresh_keys_and_stores_are_isolated() {
    let first = Key::<u32>::new();
    let cloned = first.clone();
    let second = Key::<u32>::new();
    assert!(first == cloned);
    assert!(first != second);

    let mut keys = HashSet::new();
    assert!(keys.insert(first.clone()));
    assert!(!keys.insert(cloned));
    assert!(keys.insert(second.clone()));

    let left = Store::new();
    let right = Store::new();
    assert!(left.set(&first, Arc::new(1)).is_none());
    assert!(left.set(&second, Arc::new(2)).is_none());
    assert_eq!(*left.load(&first).unwrap(), 1);
    assert_eq!(*left.load(&second).unwrap(), 2);
    assert!(right.load(&first).is_none());
    assert!(right.set(&first, Arc::new(3)).is_none());
    assert_eq!(*left.load(&first).unwrap(), 1);
    assert_eq!(*right.load(&first).unwrap(), 3);
}

#[test]
fn slot_lifecycle_preserves_arc_identity_and_explicit_none_presence() {
    let store = Store::new();
    let key = Key::<String>::new();
    assert!(store.load(&key).is_none());
    assert!(store.delete(&key).is_none());

    let original = Arc::new(String::from("first"));
    assert!(store.set(&key, Arc::clone(&original)).is_none());
    let loaded = store.load(&key).unwrap();
    assert!(Arc::ptr_eq(&loaded, &original));

    let replacement = Arc::new(String::from("second"));
    let previous = store.set(&key, Arc::clone(&replacement)).unwrap();
    assert!(Arc::ptr_eq(&previous, &original));
    let deleted = store.delete(&key).unwrap();
    assert!(Arc::ptr_eq(&deleted, &replacement));
    assert!(store.load(&key).is_none());

    let optional = Key::<Option<u8>>::new();
    let none = Arc::new(None);
    let (inserted, loaded) = store.load_or_store(&optional, Arc::clone(&none));
    assert!(!loaded);
    assert!(Arc::ptr_eq(&inserted, &none));
    let (existing, loaded) = store.load_or_store(&optional, Arc::new(Some(1)));
    assert!(loaded);
    assert!(existing.is_none());
}

#[test]
fn store_holds_exactly_one_arc_until_replaced_or_deleted() {
    struct CountDrop(Arc<AtomicUsize>);
    impl Drop for CountDrop {
        fn drop(&mut self) {
            self.0.fetch_add(1, Ordering::SeqCst);
        }
    }

    let drops = Arc::new(AtomicUsize::new(0));
    let store = Store::new();
    let key = Key::<CountDrop>::new();
    let first = Arc::new(CountDrop(Arc::clone(&drops)));
    store.set(&key, Arc::clone(&first));
    drop(first);
    assert_eq!(drops.load(Ordering::SeqCst), 0);

    let second = Arc::new(CountDrop(Arc::clone(&drops)));
    let old = store.set(&key, Arc::clone(&second)).unwrap();
    assert_eq!(drops.load(Ordering::SeqCst), 0);
    drop(old);
    assert_eq!(drops.load(Ordering::SeqCst), 1);
    drop(second);
    assert_eq!(drops.load(Ordering::SeqCst), 1);
    drop(store.delete(&key));
    assert_eq!(drops.load(Ordering::SeqCst), 2);
}

#[test]
fn concurrent_fresh_keys_are_unique_and_load_or_store_has_one_winner() {
    const WORKERS: usize = 24;
    let store = Arc::new(Store::new());
    let shared = Arc::new(Key::<usize>::new());
    let barrier = Arc::new(Barrier::new(WORKERS));
    let inserted = Arc::new(AtomicUsize::new(0));

    let handles: Vec<_> = (0..WORKERS)
        .map(|value| {
            let store = Arc::clone(&store);
            let shared = Arc::clone(&shared);
            let barrier = Arc::clone(&barrier);
            let inserted = Arc::clone(&inserted);
            thread::spawn(move || {
                let fresh = Key::<usize>::new();
                store.set(&fresh, Arc::new(value));
                barrier.wait();
                let (_, loaded) = store.load_or_store(&shared, Arc::new(value));
                if !loaded {
                    inserted.fetch_add(1, Ordering::SeqCst);
                }
                (fresh, value)
            })
        })
        .collect();

    let mut keys = HashSet::new();
    for handle in handles {
        let (key, value) = handle.join().unwrap();
        assert!(keys.insert(key.clone()));
        assert_eq!(*store.load(&key).unwrap(), value);
        assert_eq!(*store.delete(&key).unwrap(), value);
    }
    assert_eq!(inserted.load(Ordering::SeqCst), 1);
    assert!(store.load(&shared).is_some());
}

#[test]
fn private_type_corruption_panics_instead_of_becoming_a_miss() {
    let store = Store::new();
    let key = Key::<u32>::new();
    run_state::corrupt(&store, &key, Arc::new(String::from("wrong")));
    let panic = std::panic::catch_unwind(|| store.load(&key));
    assert!(panic.is_err());
}

#[test]
fn key_debug_prints_a_slot_identity_with_no_value_bound() {
    // `Key<T>` carries no `T`, so requiring `T: Debug` would make a key
    // unprintable for exactly the opaque payloads run state exists to hold.
    struct NotDebug;
    let key = Key::<NotDebug>::new();
    let cloned = key.clone();
    let other = Key::<NotDebug>::new();

    let rendering = format!("{key:?}");
    assert!(rendering.starts_with("Key { slot: 0x"), "{rendering}");
    assert_eq!(rendering, format!("{cloned:?}"));
    assert_ne!(rendering, format!("{other:?}"));
}

#[test]
fn store_debug_counts_occupied_slots_and_never_waits_for_them() {
    let store = Store::new();
    assert_eq!(format!("{store:?}"), "Store { slots: 0 }");
    let key = Key::<u32>::new();
    store.set(&key, Arc::new(7));
    assert_eq!(format!("{store:?}"), "Store { slots: 1 }");

    let held = Barrier::new(2);
    let release = Barrier::new(2);
    thread::scope(|scope| {
        scope.spawn(|| run_state::hold_slot_lock(&store, &held, &release));
        held.wait();
        assert_eq!(format!("{store:?}"), "Store { slots: <locked> }");
        release.wait();
    });
    assert_eq!(format!("{store:?}"), "Store { slots: 1 }");
}