Struct TxMock 

pub struct TxMock { /* private fields */ }

Available on crate feature provider only.

Mock transaction implementation for testing and development.

Implements both DbTx and DbTxMut traits. All operations are no-ops that return success or default values, suitable for testing database operations without side effects.

Trait Implementations

impl Clone for TxMock

fn clone(&self) -> TxMock

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DbTx for TxMock

fn get<T>( &self, _key: <T as Table>::Key, ) -> Result<Option<<T as Table>::Value>, DatabaseError>

where T: Table,

Retrieves a value by key from the specified table.

Mock behavior: Always returns None regardless of the key. This simulates a table with no data, which is typical for testing scenarios where you want to verify that read operations are called correctly without actually storing data.

fn get_by_encoded_key<T>( &self, _key: &<<T as Table>::Key as Encode>::Encoded, ) -> Result<Option<<T as Table>::Value>, DatabaseError>

where T: Table,

Retrieves a value by encoded key from the specified table.

Mock behavior: Always returns None regardless of the encoded key. This is equivalent to Self::get but works with pre-encoded keys.

fn commit(self) -> Result<bool, DatabaseError>

Commits the transaction.

Mock behavior: Always returns Ok(true), indicating successful commit. No actual data is persisted since this is a mock implementation.

fn abort(self)

Aborts the transaction.

Mock behavior: No-op. Since no data is actually stored in the mock, there’s nothing to rollback.

fn cursor_read<T>(&self) -> Result<<TxMock as DbTx>::Cursor<T>, DatabaseError>

where T: Table,

Creates a read-only cursor for the specified table.

Mock behavior: Returns a default CursorMock that will not iterate over any data (all cursor operations return None).

fn cursor_dup_read<T>( &self, ) -> Result<<TxMock as DbTx>::DupCursor<T>, DatabaseError>

where T: DupSort,

Creates a read-only duplicate cursor for the specified duplicate sort table.

Mock behavior: Returns a default CursorMock that will not iterate over any data (all cursor operations return None).

fn entries<T>(&self) -> Result<usize, DatabaseError>

where T: Table,

Returns the number of entries in the specified table.

Mock behavior: Returns the length of the internal _table BTreeMap, which is typically 0 since no data is actually stored.

fn disable_long_read_transaction_safety(&mut self)

Disables long read transaction safety checks.

Mock behavior: No-op. This is a performance optimization that doesn’t apply to the mock implementation.

type Cursor<T: Table> = CursorMock

Cursor type for this read-only transaction

type DupCursor<T: DupSort> = CursorMock

DupCursor type for this read-only transaction

impl DbTxMut for TxMock

fn put<T>( &self, _key: <T as Table>::Key, _value: <T as Table>::Value, ) -> Result<(), DatabaseError>

where T: Table,

Inserts or updates a key-value pair in the specified table.

Mock behavior: Always returns Ok(()) without actually storing the data. This allows tests to verify that write operations are called correctly without side effects.

fn delete<T>( &self, _key: <T as Table>::Key, _value: Option<<T as Table>::Value>, ) -> Result<bool, DatabaseError>

where T: Table,

Deletes a key-value pair from the specified table.

Mock behavior: Always returns Ok(true), indicating successful deletion, without actually removing any data.

fn clear<T>(&self) -> Result<(), DatabaseError>

where T: Table,

Clears all entries from the specified table.

Mock behavior: Always returns Ok(()) without actually clearing any data. This simulates successful table clearing for testing purposes.

fn cursor_write<T>( &self, ) -> Result<<TxMock as DbTxMut>::CursorMut<T>, DatabaseError>

where T: Table,

Creates a write cursor for the specified table.

Mock behavior: Returns a default CursorMock that will not iterate over any data and all write operations will be no-ops.

fn cursor_dup_write<T>( &self, ) -> Result<<TxMock as DbTxMut>::DupCursorMut<T>, DatabaseError>

where T: DupSort,

Creates a write duplicate cursor for the specified duplicate sort table.

Mock behavior: Returns a default CursorMock that will not iterate over any data and all write operations will be no-ops.

type CursorMut<T: Table> = CursorMock

Read-Write Cursor type

type DupCursorMut<T: DupSort> = CursorMock

Read-Write DupCursor type

fn append<T>( &self, key: <T as Table>::Key, value: <T as Table>::Value, ) -> Result<(), DatabaseError>

where T: Table,

Append value with the largest key to database. This should have the same outcome as put, but databases like MDBX provide dedicated modes to make it much faster, typically from O(logN) down to O(1) thanks to no lookup.

impl Debug for TxMock

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for TxMock

fn default() -> TxMock

Returns the “default value” for a type.

impl TableImporter for TxMock

fn import_table<T, R>(&self, source_tx: &R) -> Result<(), DatabaseError>

where T: Table, R: DbTx,

Imports all table data from another transaction.

fn import_table_with_range<T, R>( &self, source_tx: &R, from: Option<<T as Table>::Key>, to: <T as Table>::Key, ) -> Result<(), DatabaseError>

where T: Table, R: DbTx, <T as Table>::Key: Default,

Imports table data from another transaction within a range.

fn import_dupsort<T, R>(&self, source_tx: &R) -> Result<(), DatabaseError>

where T: DupSort, R: DbTx,

Imports all dupsort data from another transaction.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes