use super::*;
#[test]
fn dynamic_threshold_without_shared_budget_returns_base() {
assert_eq!(calculate_dynamic_threshold(30_000, None, 12_345), 30_000);
}
#[test]
fn dynamic_threshold_with_shared_budget_uses_remaining_space() {
assert_eq!(
calculate_dynamic_threshold(30_000, Some(70_000), 10_000),
60_000
);
assert_eq!(
calculate_dynamic_threshold(30_000, Some(70_000), 50_000),
30_000
);
}
#[test]
fn select_activation_boundary_prefers_under_target_boundary() {
let chunks = vec![
chunk(1, 1000, 200, &["m1"]),
chunk(2, 1200, 250, &["m2"]),
chunk(3, 1800, 300, &["m3"]),
];
let boundary = select_activation_boundary(&chunks, 0.8, 5000, 6000);
assert_eq!(boundary.chunks_activated, 3);
assert_eq!(boundary.message_tokens_activated, 4000);
assert_eq!(boundary.observation_tokens_activated, 750);
assert_eq!(boundary.activated_message_ids, vec!["m1", "m2", "m3"]);
}
#[test]
fn select_activation_boundary_returns_zero_for_empty_chunks() {
let boundary = select_activation_boundary(&[], 0.8, 5000, 6000);
assert_eq!(boundary.chunks_activated, 0);
assert_eq!(boundary.message_tokens_activated, 0);
}
#[test]
fn select_activation_boundary_saturates_token_totals_to_u32_max() {
let chunks = vec![
chunk(1, u32::MAX, u32::MAX, &["m1"]),
chunk(2, u32::MAX, u32::MAX, &["m2"]),
];
let boundary = select_activation_boundary(&chunks, 1.0, 1, u32::MAX);
assert_eq!(boundary.message_tokens_activated, u32::MAX);
assert_eq!(boundary.observation_tokens_activated, u32::MAX);
}
#[test]
fn merge_activated_observations_appends_chunk_observations() {
let chunks = vec![chunk(1, 1000, 200, &["m1"]), chunk(2, 1200, 250, &["m2"])];
let merged = merge_activated_observations("active", &chunks);
assert_eq!(merged, "active\n\nobs-1\n\nobs-2");
}
#[test]
fn normalize_observation_buffer_boundary_clamps_to_current_tokens() {
assert_eq!(normalize_observation_buffer_boundary(100, 80), 80);
assert_eq!(normalize_observation_buffer_boundary(100, 140), 100);
}
#[test]
fn activate_buffered_observations_updates_record_and_chunk_state() {
let now = Utc.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
let mut record = OmRecord {
id: "r1".to_string(),
scope: OmScope::Session,
scope_key: "session:s1".to_string(),
session_id: Some("s1".to_string()),
thread_id: None,
resource_id: None,
generation_count: 0,
last_applied_outbox_event_id: None,
origin_type: OmOriginType::Initial,
active_observations: "active".to_string(),
observation_token_count: 10,
pending_message_tokens: 6_000,
last_observed_at: None,
current_task: None,
suggested_response: None,
last_activated_message_ids: vec!["existing".to_string()],
observer_trigger_count_total: 0,
reflector_trigger_count_total: 0,
is_observing: false,
is_reflecting: false,
is_buffering_observation: true,
is_buffering_reflection: false,
last_buffered_at_tokens: 6_000,
last_buffered_at_time: Some(now),
buffered_reflection: None,
buffered_reflection_tokens: None,
buffered_reflection_input_tokens: None,
created_at: now,
updated_at: now,
};
let mut chunks = vec![
OmObservationChunk {
id: "c1".to_string(),
record_id: "r1".to_string(),
seq: 1,
cycle_id: "cycle-1".to_string(),
observations: "obs-1".to_string(),
token_count: 200,
message_tokens: 1_000,
message_ids: vec!["m1".to_string()],
last_observed_at: now,
created_at: now,
},
OmObservationChunk {
id: "c2".to_string(),
record_id: "r1".to_string(),
seq: 2,
cycle_id: "cycle-2".to_string(),
observations: "obs-2".to_string(),
token_count: 250,
message_tokens: 1_200,
message_ids: vec!["m2".to_string()],
last_observed_at: now + Duration::minutes(1),
created_at: now + Duration::minutes(1),
},
];
let activated =
activate_buffered_observations(&mut record, &mut chunks, 0.8, 5_000).expect("activate");
assert_eq!(activated.activated_max_seq, 2);
assert_eq!(activated.chunks_activated, 2);
assert_eq!(record.active_observations, "active\n\nobs-1\n\nobs-2");
assert_eq!(record.observation_token_count, 460);
assert_eq!(record.pending_message_tokens, 3_800);
assert_eq!(
record.last_activated_message_ids,
vec!["existing".to_string(), "m1".to_string(), "m2".to_string()]
);
assert!(!record.is_buffering_observation);
assert_eq!(record.last_buffered_at_tokens, 0);
assert_eq!(record.last_buffered_at_time, None);
assert!(chunks.is_empty());
}
#[test]
fn activate_buffered_observations_returns_result_for_seq_zero_chunks() {
let now = Utc.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
let mut record = OmRecord {
id: "r-seq0".to_string(),
scope: OmScope::Session,
scope_key: "session:s1".to_string(),
session_id: Some("s1".to_string()),
thread_id: None,
resource_id: None,
generation_count: 0,
last_applied_outbox_event_id: None,
origin_type: OmOriginType::Initial,
active_observations: String::new(),
observation_token_count: 0,
pending_message_tokens: 1_000,
last_observed_at: None,
current_task: None,
suggested_response: None,
last_activated_message_ids: Vec::new(),
observer_trigger_count_total: 0,
reflector_trigger_count_total: 0,
is_observing: false,
is_reflecting: false,
is_buffering_observation: true,
is_buffering_reflection: false,
last_buffered_at_tokens: 1_000,
last_buffered_at_time: Some(now),
buffered_reflection: None,
buffered_reflection_tokens: None,
buffered_reflection_input_tokens: None,
created_at: now,
updated_at: now,
};
let mut chunks = vec![OmObservationChunk {
id: "c-seq0".to_string(),
record_id: "r-seq0".to_string(),
seq: 0,
cycle_id: "cycle-0".to_string(),
observations: "obs-seq0".to_string(),
token_count: 50,
message_tokens: 1_000,
message_ids: vec!["m-seq0".to_string()],
last_observed_at: now,
created_at: now,
}];
let activated =
activate_buffered_observations(&mut record, &mut chunks, 0.8, 5_000).expect("activate");
assert_eq!(activated.activated_max_seq, 0);
assert_eq!(activated.chunks_activated, 1);
assert_eq!(record.active_observations, "obs-seq0");
assert_eq!(record.observation_token_count, 50);
assert_eq!(record.pending_message_tokens, 0);
assert!(chunks.is_empty());
}
#[test]
fn activate_buffered_observations_normalizes_boundary_when_buffer_remains() {
let now = Utc.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
let mut record = OmRecord {
id: "r-boundary".to_string(),
scope: OmScope::Session,
scope_key: "session:s1".to_string(),
session_id: Some("s1".to_string()),
thread_id: None,
resource_id: None,
generation_count: 0,
last_applied_outbox_event_id: None,
origin_type: OmOriginType::Initial,
active_observations: String::new(),
observation_token_count: 0,
pending_message_tokens: 7_000,
last_observed_at: None,
current_task: None,
suggested_response: None,
last_activated_message_ids: Vec::new(),
observer_trigger_count_total: 0,
reflector_trigger_count_total: 0,
is_observing: false,
is_reflecting: false,
is_buffering_observation: true,
is_buffering_reflection: false,
last_buffered_at_tokens: 7_000,
last_buffered_at_time: Some(now),
buffered_reflection: None,
buffered_reflection_tokens: None,
buffered_reflection_input_tokens: None,
created_at: now,
updated_at: now,
};
let mut chunks = vec![
chunk(1, 2_000, 100, &["m1"]),
chunk(2, 2_000, 100, &["m2"]),
chunk(3, 2_000, 100, &["m3"]),
];
let activated =
activate_buffered_observations(&mut record, &mut chunks, 0.2, 5_000).expect("activate");
assert_eq!(activated.chunks_activated, 1);
assert!(record.is_buffering_observation);
assert_eq!(record.pending_message_tokens, 5_000);
assert_eq!(record.last_buffered_at_tokens, 5_000);
assert_eq!(chunks.len(), 2);
}