reef-core 0.4.0

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

use std::sync::Arc;

use super::Token;

#[test]
fn a_fresh_token_is_uncancelled_however_it_was_built() {
    for token in [Token::new(), Token::default()] {
        assert!(!token.is_cancelled());
        assert_eq!(format!("{token:?}"), "Token { cancelled: false }");
    }
}

#[test]
fn every_clone_observes_one_cancellation_and_cancelling_twice_is_idempotent() {
    let token = Token::new();
    let clone = token.clone();
    assert!(!clone.is_cancelled());

    clone.cancel();
    assert!(token.is_cancelled());
    assert!(clone.is_cancelled());
    assert_eq!(format!("{token:?}"), "Token { cancelled: true }");

    token.cancel();
    assert!(clone.is_cancelled());
}

#[test]
fn child_derivation_propagates_downward_only() {
    let parent = Token::new();
    let child = parent.child_token();
    let grandchild = child.child_token();

    // Upward isolation: a cancelled grandchild leaves its ancestors running.
    grandchild.cancel();
    assert!(grandchild.is_cancelled());
    assert!(!child.is_cancelled());
    assert!(!parent.is_cancelled());

    // Downward propagation reaches every depth, including tokens derived before
    // the parent was cancelled.
    let sibling = child.child_token();
    parent.cancel();
    assert!(child.is_cancelled());
    assert!(sibling.is_cancelled());

    // A token derived from an already-cancelled parent starts cancelled.
    assert!(parent.child_token().is_cancelled());
}

#[tokio::test]
async fn awaiting_cancellation_completes_for_an_already_cancelled_token() {
    let token = Token::new();
    token.cancel();
    token.cancelled().await;
}

#[tokio::test]
async fn awaiting_cancellation_wakes_a_waiter_cancelled_by_a_parent() {
    let parent = Token::new();
    let child = Arc::new(parent.child_token());
    let waiter = tokio::spawn({
        let child = Arc::clone(&child);
        async move {
            child.cancelled().await;
            child.is_cancelled()
        }
    });

    // The waiter is parked on a token nobody has cancelled yet; cancelling the
    // parent is what has to wake it.
    tokio::task::yield_now().await;
    assert!(!child.is_cancelled());
    parent.cancel();

    assert!(waiter.await.expect("the waiter task does not panic"));
}

#[tokio::test]
async fn dropping_a_cancellation_future_observes_nothing() {
    let token = Token::new();
    {
        let pending = token.cancelled();
        drop(pending);
    }
    assert!(!token.is_cancelled());
    token.cancel();
    token.cancelled().await;
}