Struct TestTransaction 

pub struct TestTransaction<'a> {
    pub inner: &'a mut AdminTransaction,
    pub baseline: usize,
    pub events: &'a mut Vec<CapturedEvent>,
    pub invocations: &'a mut Vec<CapturedInvocation>,
    pub event_seq: &'a mut u64,
    pub handler_seq: &'a mut u64,
    pub savepoint: Option<Savepoint>,
    pub session_type: SessionOp,
    pub session_default_deny: bool,
}

Fields

inner: &'a mut AdminTransaction

baseline: usize

events: &'a mut Vec<CapturedEvent>

invocations: &'a mut Vec<CapturedInvocation>

event_seq: &'a mut u64

handler_seq: &'a mut u64

savepoint: Option<Savepoint>

session_type: SessionOp

session_default_deny: bool

Implementations

impl<'a> TestTransaction<'a>

pub fn new( inner: &'a mut AdminTransaction, events: &'a mut Vec<CapturedEvent>, invocations: &'a mut Vec<CapturedInvocation>, event_seq: &'a mut u64, handler_seq: &'a mut u64, session_type: SessionOp, session_default_deny: bool, ) -> Self

pub fn restore(&mut self)

Restore transaction state to the savepoint captured at construction.

pub fn reborrow(&mut self) -> TestTransaction<'_>

Re-borrow this test transaction with a shorter lifetime, producing a TestTransaction suitable for embedding in a Transaction::Test variant without consuming self.

pub fn accumulator_entries_from(&self) -> &[(ShapeId, Diff)]

Read accumulator entries since the baseline. Used by testing helpers to inspect mutations within the current test.

pub fn capture_testing_pre_commit(&mut self) -> Result<()>

Execute test-only pre-commit style processing without committing.

If a test_pre_commit hook is registered on the interceptors, it is called first to ensure uncommitted flows are registered in the shared flow engine. Then the pre-commit interceptor chain runs (which includes transactional flow processing) over accumulator entries from the baseline onwards.

Used by testing helpers that need commit-time flow work materialized while still staying inside the test savepoint.