Files
prometeu-runtime/crates/console/prometeu-vm/src/string_ledger/tests.rs
T

354 lines
14 KiB
Rust

use super::*;
use crate::resource_budget::RuntimeLimits;
fn fixture(overrides: &[(Q, u64)]) -> (RuntimeBudget, StringLedger) {
let mut limits = RuntimeLimits::default();
for &(resource, ceiling) in overrides {
limits = limits.lowered(resource, ceiling).unwrap();
}
let budget = RuntimeBudget::new(limits);
let ledger = StringLedger::new(budget.clone()).unwrap();
(budget, ledger)
}
#[test]
fn clones_share_charge_but_equal_independent_allocations_do_not() {
let (budget, ledger) = fixture(&[]);
let first = ledger.import("same").unwrap();
let cloned = first.clone();
assert_eq!(budget.used(Q::StringBytes), 4);
assert_eq!(budget.used(Q::StringAllocations), 1);
let second = ledger.import("same").unwrap();
assert!(!Arc::ptr_eq(&first, &second));
assert_eq!(budget.used(Q::StringBytes), 8);
assert_eq!(budget.used(Q::StringAllocations), 2);
drop(first);
drop(second);
assert_eq!(ledger.reconcile(), 1);
assert_eq!(budget.used(Q::StringBytes), 4);
drop(cloned);
// The Weak and counters survive the last owner until reconciliation.
assert_eq!(budget.used(Q::StringBytes), 4);
assert_eq!(ledger.reconcile(), 1);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
}
#[test]
fn native_writer_quota_refusal_happens_before_callback_or_content_materialization() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 2)]);
let mut called = false;
let result = ledger.build(3, &mut |writer| {
called = true;
writer.write_str("abc")
});
assert!(
matches!(result,Err(MaterializeError::Resource(error)) if error.resource==Q::StringBytes)
);
assert!(!called);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
}
#[test]
fn native_writer_length_mismatch_cannot_grow_buffer_and_refunds_content_reservations() {
let (budget, ledger) = fixture(&[]);
for (length, text) in [(2, "abc"), (4, "abc")] {
assert!(matches!(
ledger.build(length, &mut |writer| writer.write_str(text)),
Err(MaterializeError::InvalidLength)
));
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}
let content = ledger
.build(5, &mut |writer| {
writer.write_str("é")?;
writer.write_str("猫")
})
.ok()
.unwrap();
assert_eq!(&*content, "é猫");
assert_eq!(budget.used(Q::StringBytes), 5);
assert_eq!(budget.used(Q::StringAllocations), 1);
}
#[test]
fn empty_strings_still_consume_distinct_allocation_records() {
let (budget, ledger) = fixture(&[(Q::StringAllocations, 2), (Q::StringBytes, 0)]);
let first = ledger.import("").unwrap();
let second = ledger.import("").unwrap();
assert!(!Arc::ptr_eq(&first, &second));
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 2);
let e = ledger.import("").unwrap_err();
assert_eq!((e.resource, e.requested, e.limit), (Q::StringAllocations, 3, 2));
assert_eq!(ledger.tracked_allocations(), 2);
}
#[test]
fn content_and_individual_limits_are_checked_before_materialization() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 4), (Q::IndividualStringBytes, 3)]);
assert_eq!(ledger.import("1234").unwrap_err().resource, Q::IndividualStringBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
let retained = ledger.import("123").unwrap();
let err = ledger.import("45").unwrap_err();
assert_eq!((err.resource, err.requested, err.limit), (Q::StringBytes, 5, 4));
assert_eq!(budget.used(Q::StringBytes), 3);
assert_eq!(budget.used(Q::StringAllocations), 1);
assert_eq!(&*retained, "123");
}
#[test]
fn pressure_reconciliation_reclaims_only_dead_owners_and_reuses_capacity() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 3), (Q::StringAllocations, 1)]);
let content = ledger.import("abc").unwrap();
let auxiliary = budget.used(Q::AuxiliaryBytes);
assert!(ledger.import("abc").is_err());
drop(content);
let replacement = ledger.import("xyz").unwrap();
assert_eq!(&*replacement, "xyz");
assert_eq!(budget.used(Q::StringBytes), 3);
assert_eq!(budget.used(Q::StringAllocations), 1);
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
}
#[test]
fn allocation_count_failure_refunds_provisional_content_charge() {
let (budget, ledger) = fixture(&[(Q::StringAllocations, 0)]);
assert_eq!(ledger.import("abc").unwrap_err().resource, Q::StringAllocations);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}
#[test]
fn ledger_growth_is_fallible_and_keeps_live_records_on_refusal() {
let state = (size_of::<Mutex<Domain>>() + 2 * size_of::<usize>()) as u64;
let (budget, ledger) = fixture(&[(Q::AuxiliaryBytes, state)]);
assert_eq!(ledger.import("abc").unwrap_err().resource, Q::AuxiliaryBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::AuxiliaryBytes), state);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}
#[test]
fn concatenation_accounts_utf8_length_and_temporary_result_coexistence() {
let (budget, ledger) = fixture(&[(Q::StringBytes, 5), (Q::TemporaryBytes, 5)]);
let result = ledger.concat("é", "猫").unwrap();
assert_eq!(&*result, "é猫");
assert_eq!(budget.used(Q::StringBytes), 5);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(ledger.tracked_allocations(), 1);
}
#[test]
fn temporary_refusal_leaves_no_published_content_or_content_reservation() {
let (budget, ledger) = fixture(&[(Q::TemporaryBytes, 2)]);
let error = ledger.concat("ab", "c").unwrap_err();
assert_eq!((error.resource, error.requested, error.limit), (Q::TemporaryBytes, 3, 2));
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(ledger.tracked_allocations(), 0);
// Direct import does not need a temporary concatenation buffer.
let imported = ledger.import("abc").unwrap();
assert_eq!(&*imported, "abc");
}
#[test]
fn foreign_arc_import_copies_into_destination_without_implicit_session_sharing() {
let (first_budget, first) = fixture(&[]);
let (second_budget, second) = fixture(&[]);
let source = first.import("text").unwrap();
assert!(first.retains(&source));
assert!(!second.retains(&source));
assert!(second.lease(&source).is_none());
let imported = second.import(&source).unwrap();
assert!(!Arc::ptr_eq(&source, &imported));
assert!(second.retains(&imported));
assert_eq!(first_budget.used(Q::StringBytes), 4);
assert_eq!(second_budget.used(Q::StringBytes), 4);
}
#[test]
fn native_provenance_lease_keeps_accounting_domain_alive_after_session_owner() {
let (budget, ledger) = fixture(&[]);
let content = ledger.import("kept").unwrap();
let host = ledger.lease(&content).unwrap();
let tool = host.clone();
drop(content);
drop(ledger);
assert_eq!(&**host.content(), "kept");
assert_eq!(host.domain().reconcile(), 0);
assert_eq!(budget.used(Q::StringBytes), 4);
drop(host);
assert_eq!(budget.used(Q::StringAllocations), 1);
drop(tool);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
}
#[test]
fn shared_domain_survives_one_consumer_and_final_drop_releases_weak_storage() {
let (budget, ledger) = fixture(&[]);
let shared = ledger.clone();
let value = ledger.import("image").unwrap();
drop(ledger);
assert!(shared.retains(&value));
assert_eq!(budget.used(Q::StringBytes), 5);
drop(value);
shared.reconcile();
assert_eq!(budget.used(Q::StringBytes), 0);
assert!(budget.used(Q::AuxiliaryBytes) > 0);
drop(shared);
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
}
#[test]
fn domain_construction_refusal_does_not_publish_a_partial_owner() {
let budget =
RuntimeBudget::new(RuntimeLimits::default().lowered(Q::AuxiliaryBytes, 0).unwrap());
assert_eq!(StringLedger::new(budget.clone()).unwrap_err().resource, Q::AuxiliaryBytes);
assert_eq!(budget.used(Q::AuxiliaryBytes), 0);
}
#[test]
fn bounded_formatting_preserves_existing_value_text_without_unmetered_string_buffers() {
let (budget, ledger) = fixture(&[]);
for value in [
Value::Int32(i32::MIN),
Value::Int64(i64::MAX),
Value::Float(-0.0),
Value::Float(f64::MAX),
Value::Float(f64::NAN),
Value::Boolean(false),
Value::Null,
Value::HeapRef(prometeu_bytecode::HeapRef { index: u32::MAX, generation: 7 }),
Value::String(Arc::from("é猫")),
] {
let text = ledger.format(&value).unwrap();
assert_eq!(&*text, value.to_string());
assert_eq!(budget.used(Q::TemporaryBytes), 0);
drop(text);
ledger.reconcile();
assert_eq!(budget.used(Q::StringBytes), 0);
}
let text = ledger.concat_values(&Value::String(Arc::from("x=")), &Value::Int64(42)).unwrap();
assert_eq!(&*text, "x=42");
assert_eq!(budget.used(Q::StringBytes), 4);
}
#[test]
fn formatting_refuses_result_and_temporary_limits_with_no_content_publication() {
let (budget, ledger) = fixture(&[(Q::IndividualStringBytes, 2)]);
assert_eq!(ledger.format(&Value::Int32(123)).unwrap_err().resource, Q::IndividualStringBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(ledger.tracked_allocations(), 0);
let (budget, ledger) = fixture(&[(Q::TemporaryBytes, 2)]);
assert_eq!(ledger.format(&Value::Boolean(false)).unwrap_err().resource, Q::TemporaryBytes);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
assert_eq!(ledger.tracked_allocations(), 0);
}
#[test]
fn index_growth_refuses_auxiliary_temporary_and_allocator_before_materialization() {
for failure in [0, 1, 2] {
let (budget, ledger) = fixture(&[]);
let kept = (0..4).map(|_| ledger.import("kept").unwrap()).collect::<Vec<_>>();
let auxiliary = budget.used(Q::AuxiliaryBytes);
match failure {
0 => budget.test_lower_limit(Q::AuxiliaryBytes, auxiliary),
1 => budget.test_lower_limit(Q::TemporaryBytes, 0),
_ => crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true)),
}
let mut called = false;
let result = ledger.build(4, &mut |w| {
called = true;
w.write_str("next")
});
let Err(MaterializeError::Resource(error)) = result else {
panic!("expected prepublication refusal")
};
assert!(!called);
assert_eq!(
error.resource,
if failure == 1 { Q::TemporaryBytes } else { Q::AuxiliaryBytes }
);
assert_eq!(
error.reason,
if failure == 2 { ResourceReason::AllocationFailed } else { ResourceReason::Limit }
);
assert_eq!(ledger.tracked_allocations(), 4);
assert_eq!(budget.used(Q::StringBytes), 16);
assert_eq!(budget.used(Q::StringAllocations), 4);
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
for value in &kept {
assert!(ledger.retains(value));
}
}
}
#[test]
fn index_initial_allocation_failure_and_rebuild_failure_refund_reservations() {
let (budget, ledger) = fixture(&[]);
let initial = budget.used(Q::AuxiliaryBytes);
crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true));
assert_eq!(ledger.import("x").unwrap_err().reason, ResourceReason::AllocationFailed);
assert_eq!(ledger.tracked_allocations(), 0);
assert_eq!(budget.used(Q::AuxiliaryBytes), initial);
assert_eq!(budget.used(Q::StringBytes), 0);
assert_eq!(budget.used(Q::StringAllocations), 0);
let mut kept = (0..4).map(|_| ledger.import("same").unwrap()).collect::<Vec<_>>();
let old = Arc::downgrade(&kept.pop().unwrap());
assert_eq!(ledger.reconcile(), 1);
let auxiliary = budget.used(Q::AuxiliaryBytes);
budget.test_lower_limit(Q::TemporaryBytes, 0);
assert_eq!(ledger.import("new").unwrap_err().resource, Q::TemporaryBytes);
assert_eq!(ledger.tracked_allocations(), 3);
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert_eq!(budget.used(Q::StringBytes), 12);
for value in &kept {
assert_eq!(Arc::strong_count(value), 1);
assert!(ledger.retains(value));
}
assert!(old.upgrade().is_none());
// Rebuild under a restored test budget; no production ceiling changes.
budget.test_lower_limit(Q::TemporaryBytes, 64 * 1024 * 1024);
let newer = ledger.import("same").unwrap();
assert!(ledger.retains(&newer));
assert!(!ledger.retains(&Arc::from("same")));
assert!(ledger.lookup_work(&newer).0);
}
#[test]
fn tombstone_rebuild_allocator_refusal_preserves_live_keys_and_charges() {
let (budget, ledger) = fixture(&[]);
let mut owners = (0..4).map(|_| ledger.import("same").unwrap()).collect::<Vec<_>>();
owners.pop();
assert_eq!(ledger.reconcile(), 1);
let auxiliary = budget.used(Q::AuxiliaryBytes);
crate::resource_budget::FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.set(true));
assert_eq!(ledger.import("new").unwrap_err().reason, ResourceReason::AllocationFailed);
assert_eq!(ledger.tracked_allocations(), 3);
assert_eq!(budget.used(Q::StringBytes), 12);
assert_eq!(budget.used(Q::StringAllocations), 3);
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
assert_eq!(budget.used(Q::TemporaryBytes), 0);
assert!(owners.iter().all(|v| ledger.retains(v)));
let new = ledger.import("new").unwrap();
assert!(ledger.retains(&new));
assert_eq!(budget.used(Q::AuxiliaryBytes), auxiliary);
}