Struct MockShell 

pub struct MockShell { /* private fields */ }

Implementations

impl MockShell

pub fn new() -> Self

pub fn with_ref_target( self, relation: impl Into<String>, target: MockShell, ) -> Self

Register the target store for a foreign-key relation declared in metadata (via VistaMetadata::with_reference). get_ref(relation, row) then returns this store narrowed by foreign_key == parent_row[id] — the in-memory analogue of a driver resolving a with_one/with_many.

pub fn set_fail_reads(&self, fail: bool)

Flip read failure on/off. While true, list/get/count return Err. Shared across clones (incl. narrowed get_ref results) via Arc, so a handle kept before the shell is registered/boxed can fail the live dataset mid-run — simulating a source that goes offline.

pub fn with_capabilities(self, capabilities: VistaCapabilities) -> Self

pub fn with_metadata(self, metadata: VistaMetadata) -> Self

pub fn with_id_prefix(self, prefix: impl Into<String>) -> Self

Qualify every id with prefix, the way a driver that owns its key space does: a record inserted as abc is stored — and returned — as client:abc. An id that already carries the prefix passes through, so a caller can address a row in either form.

pub fn with_record( self, id: impl Into<String>, record: Record<CborValue>, ) -> Self

Seed a record with an explicit id.

pub fn set_record(&self, id: impl Into<String>, record: Record<CborValue>)

Insert or replace a record by id through the shared store.

pub fn set_field(&self, id: &str, field: &str, value: CborValue)

Overwrite a single field of an existing record (read-modify-write). No-op if the record is absent.

pub fn remove_record(&self, id: &str)

Remove a record by id. No-op if absent.

pub fn clear_records(&self)

Drop every record.

pub fn len(&self) -> usize

Number of records currently held. Companion to the live-mutation helpers above, for tests/examples that grow or shrink the store at runtime and want to assert on its size without an async list.

pub fn is_empty(&self) -> bool

Whether the store holds no records.

pub fn get_record(&self, id: &str) -> Option<Record<CborValue>>

Snapshot one record by id, straight off the store — no conditions, no fail_reads guard. Companion to the live-mutation helpers: an effect or test reading what it is about to mutate is inspecting its own store, not querying a source.

pub fn record_ids(&self) -> Vec<String>

Ids currently held, in store order. Same store-side view as Self::get_record.

Trait Implementations

impl Clone for MockShell

fn clone(&self) -> MockShell

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for MockShell

fn default() -> Self

Returns the “default value” for a type.

impl TableShell for MockShell

fn get_contained_ref( &self, relation: &str, row: &Record<CborValue>, ) -> Result<Vista>

Resolve a contained relation against row, with a writeback that patches the parent record’s host column directly in this mock’s store — the in-memory analogue of a driver patching its row.

fn get_ref(&self, relation: &str, row: &Record<CborValue>) -> Result<Vista>

Resolve a foreign-key relation to its registered target store, narrowed by foreign_key == parent_row[id]. This is a pure descriptor operation (no read), so it succeeds even while the target’s fail_reads is set — the failure surfaces later, at load time, on the returned Vista.

fn fetch_window<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, offset: usize, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Record<CborValue>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Windowed read that honours the shell’s current add_order — the mock’s analogue of a driver serving an ordered [offset, limit) page. Gated by can_fetch_window like every driver.

Clones only the returned window. The obvious implementation — list everything, then slice — copies the whole store per window, which on a large mock (200k rows) turns every “fast” page into a near-second stall and made the shaped-faker latency knobs meaningless. Filtering and ordering work over references; records are cloned after the slice.

fn clone_shell(&self) -> Option<Box<dyn TableShell>>

Share the backing store, but give the copy its own query state (filters / order / search) — the clone_shell contract. MockShell’s derived Clone shares those (they’re Arc<Mutex<_>>), so it can’t be used here: narrowing the clone (e.g. add_order in Dio::fetch_window_ordered) must not reach back and reorder the original. data / next_auto_id / fail_reads stay shared (the store).

fn insert_vista_value<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _vista: &'life1 Vista, id: &'life2 String, record: &'life3 Record<CborValue>, ) -> Pin<Box<dyn Future<Output = Result<Record<CborValue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store the record and report it back carrying the key it landed under. The key goes into the vista’s id column, not a literal id field: a caller that reads the id back off the returned record — a cache settling a create, for one — reads the column the metadata declares, so a mock configured with a different id column must answer in that column too.

fn insert_vista_return_id_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, vista: &'life1 Vista, record: &'life2 Record<CborValue>, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert and report the id the record is addressable by. That is the store key, prefix included: the caller uses this id to read the row back, so it must be the same id the by-id insert path stores under.

fn get_vista_count<'life0, 'life1, 'async_trait>( &'life0 self, vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count without materializing: list_vista_values clones every matching record just to take a length, which turns each counted window fetch on a large store into a full-store copy (1.8 s against a 200k-row mock). Counting only needs the predicates.

fn columns(&self) -> &IndexMap<String, Column>

fn references(&self) -> &IndexMap<String, Reference>

fn contained(&self) -> &IndexMap<String, ContainedSpec>

Contained (embedded-in-row) relations this shell exposes, keyed by name. Default empty — only shells that model embedded objects/arrays override.

fn id_column(&self) -> Option<&str>

fn list_vista_values<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<String, Record<CborValue>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_vista_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _vista: &'life1 Vista, id: &'life2 String, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<CborValue>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_vista_some_value<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Record<CborValue>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn replace_vista_value<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _vista: &'life1 Vista, id: &'life2 String, record: &'life3 Record<CborValue>, ) -> Pin<Box<dyn Future<Output = Result<Record<CborValue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn patch_vista_value<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _vista: &'life1 Vista, id: &'life2 String, partial: &'life3 Record<CborValue>, ) -> Pin<Box<dyn Future<Output = Result<Record<CborValue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn delete_vista_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _vista: &'life1 Vista, id: &'life2 String, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn delete_vista_all_values<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn capabilities(&self) -> &VistaCapabilities

fn driver_name(&self) -> &'static str

Short human label for the underlying driver (e.g. "csv", "sqlite", "postgres", "mongodb"). Used for diagnostics and CLI output. Drivers should override; the default is a placeholder.

fn add_eq_condition(&mut self, field: &str, value: &CborValue) -> Result<()>

Translate field == value into the driver’s native condition type and apply it to the wrapped table. The default impl returns Unimplemented — every driver is expected to override.

fn add_order(&mut self, field: &str, dir: SortDirection) -> Result<()>

Push a single ORDER BY clause onto the wrapped table.

fn clear_orders(&mut self) -> Result<()>

Wipe every order clause. Default mirrors add_order.

fn add_search(&mut self, text: &str) -> Result<()>

Apply a quicksearch filter — a single string the driver fans out across the columns it considers searchable (typically those flagged SEARCHABLE, but each driver decides).

fn clear_search(&mut self) -> Result<()>

Drop the search filter previously applied via add_search. Default mirrors add_search.

fn get_vista_value_with_row<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, vista: &'life1 Vista, id: &'life2 String, _row: &'life3 Record<CborValue>, ) -> Pin<Box<dyn Future<Output = Result<Option<Record<CborValue>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Fetch one record by id, with the caller’s existing (cheap) record available to drivers that can use it (e.g. a cmd detail script reading list-pass columns). The default ignores row and delegates to get_vista_value; only drivers that benefit override it.

fn stream_vista_values<'a>( &'a self, vista: &'a Vista, ) -> Pin<Box<dyn Stream<Item = Result<(String, Record<CborValue>)>> + Send + 'a>>

where Self: Sync,

Default implementation wraps list_vista_values. Drivers with native streaming (cursor-based queries, paginated REST APIs) override.

fn aggregate_vista( &self, _vista: &Vista, _spec: &AggregateSpec, ) -> Result<Option<Vista>>

Derive a new vista that reduces this one — the driver’s equivalent of selecting from a subquery.

fn add_op_condition( &mut self, field: &str, op: FilterOp, value: &CborValue, ) -> Result<()>

Translate field <op> value into the driver’s native condition and apply it. The default routes Eq to add_eq_condition (so every driver gets equality for free) and returns Unimplemented for every richer operator. Drivers whose query language expresses the operators (SQL, SurrealDB) override this and advertise can_filter_operators; consumers that see false skip the call and filter locally instead.

fn add_raw_condition( &mut self, _condition: Box<dyn Any + Send + Sync>, ) -> Result<()>

Push a driver-native condition into the wrapped table. The caller boxes the condition as dyn Any and the driver downcasts to its own T::Condition. Used by YAML-driven relation traversal, where the factory constructs a DeferredFn-bearing condition outside the value-set surface (which only accepts scalar eq) and pushes it through this channel. Default is Unimplemented.

fn set_page_size(&mut self, _size: usize) -> Result<()>

Declare how many records constitute one page. Used by both fetch_page and fetch_next. Default returns default_error("set_page_size", "can_set_page_size").

fn fetch_page<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _page: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Record<CborValue>)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a specific page (1-based) using offset-style pagination. The per-page count comes from the most recent set_page_size.

fn fetch_next<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, _token: Option<CborValue>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<(String, Record<CborValue>)>, Option<CborValue>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cursor-style chain fetch. Pass None on the first call; pass the previous call’s returned token on subsequent calls. Returned token is None when the result set is exhausted.

fn fetch_window_counted<'life0, 'life1, 'async_trait>( &'life0 self, vista: &'life1 Vista, offset: usize, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<(Vec<(String, Record<CborValue>)>, Option<i64>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fetch_window, plus the grand total of matching rows when this fetch already learned it.

fn get_ref_target(&self, relation: &str) -> Result<Vista>

Build the bare target of a same-persistence relation as a Vista — the table a new related row would be inserted into, with no join condition applied. Used by Vista’s nested insert to reach a has-one / has-many child’s destination.

fn get_ref_kinds(&self) -> Vec<(String, ReferenceKind)>

Names + cardinalities of the shell’s same-persistence references. Derived from references by default; impls should rarely need to override.

fn watch_vista<'life0, 'life1, 'async_trait>( &'life0 self, _vista: &'life1 Vista, ) -> Pin<Box<dyn Future<Output = Result<VistaChangeStream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Subscribe to changes on the set and stream them as VistaChanges.

fn capability_flag(&self, name: &str) -> bool

Look up a capability flag by name. Used by default_error to decide between Unsupported and Unimplemented. Drivers don’t normally need to override this.

fn default_error(&self, method: &str, capability: &str) -> VantageError

Build the standard error returned by default trait method impls.