Struct toql_core::mock_db::MockDb

pub struct MockDb<'a> { /* private fields */ }

The implementation collects all SQL statements that can be asserted. For loading it return default values.

Implementations

impl<'a> MockDb<'a>

pub fn clear_rows(&mut self)

pub fn reset_id(&mut self)

pub fn take_unsafe_sqls(&mut self) -> Vec<String>

pub fn take_unsafe_sql(&mut self) -> String

pub fn sqls_empty(&mut self) -> bool

pub fn mock_rows(&mut self, select: impl Into<String>, rows: Vec<Row>)

impl<'a> MockDb<'a>

pub fn from(cache: &'a Cache) -> MockDb<'a>

pub fn with_context(cache: &'a Cache, context: Context) -> MockDb<'a>

Trait Implementations

impl<'a> ToqlApi for MockDb<'a>

fn insert_many<'life0, 'life1, 'async_trait, T, Q>(
    &'life0 mut self,
    entities: &'life1 mut [Q],
    paths: Paths
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    T: Insert,
    Q: BorrowMut<T> + Send,
    T: 'async_trait,
    Q: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Insert one struct.

Skip fields in struct that are auto generated with #[toql(skip_inup)]. Returns the last generated id.

fn load_one<'life0, 'async_trait, T, B>(
    &'life0 mut self,
    query: B
) -> Pin<Box<dyn Future<Output = Result<T, Self::Error>> + Send + 'async_trait>> where
    T: Load<Self::Row, Self::Error>,
    B: Borrow<Query<T>> + Send + Sync,
    <T as Keyed>::Key: FromRow<Self::Row, Self::Error>,
    T: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Load a struct with dependencies for a given Toql query.

Returns a struct or a ToqlMySqlAsyncError if no struct was found NotFound or more than one NotUnique.

fn load_many<'life0, 'async_trait, T, B>(
    &'life0 mut self,
    query: B
) -> Pin<Box<dyn Future<Output = Result<Vec<T>, Self::Error>> + Send + 'async_trait>> where
    T: Load<Self::Row, Self::Error>,
    B: Borrow<Query<T>> + Send + Sync,
    <T as Keyed>::Key: FromRow<Self::Row, Self::Error>,
    T: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Load a vector of structs with dependencies for a given Toql query.

Returns a tuple with the structs and an optional tuple of count values. If count argument is false, no count queries are run and the resulting Option<(u32,u32)> will be None otherwise the count queries are run and it will be Some((total count, filtered count)).

fn load_page<'life0, 'async_trait, T, B>(
    &'life0 mut self,
    query: B,
    page: Page
) -> Pin<Box<dyn Future<Output = Result<(Vec<T>, Option<PageCounts>), Self::Error>> + Send + 'async_trait>> where
    T: Load<Self::Row, Self::Error>,
    B: Borrow<Query<T>> + Send + Sync,
    <T as Keyed>::Key: FromRow<Self::Row, Self::Error>,
    T: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Load a vector of structs with dependencies for a given Toql query.

Returns a tuple with the structs and an optional tuple of count values. If count argument is false, no count queries are run and the resulting Option<(u32,u32)> will be None otherwise the count queries are run and it will be Some((unpaged count, unfiltered count)).

fn count<'life0, 'async_trait, T, B>(
    &'life0 mut self,
    query: B
) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>> where
    T: Count,
    B: Borrow<Query<T>> + Send + Sync,
    T: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Counts the number of rows that match the query predicate.

Returns a struct or a ToqlMySqlAsyncError if no struct was found NotFound or more than one NotUnique.

type Row = Row

type Error = ToqlError

fn insert_one<'life0, 'life1, 'async_trait, T>(
    &'life0 mut self,
    entity: &'life1 mut T,
    paths: Paths
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    T: Insert,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn update_one<'life0, 'life1, 'async_trait, T>(
    &'life0 mut self,
    entity: &'life1 mut T,
    fields: Fields
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    T: Update + Keyed,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn update_many<'life0, 'life1, 'async_trait, T, Q>(
    &'life0 mut self,
    entities: &'life1 mut [Q],
    fields: Fields
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    T: Update + Keyed,
    Q: BorrowMut<T> + Send + Sync,
    T: 'async_trait,
    Q: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn delete_one<'life0, 'async_trait, K>(
    &'life0 mut self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    K: Key + Into<Query<<K as Key>::Entity>> + Send,
    <K as Key>::Entity: Send + Delete,
    K: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

fn delete_many<'life0, 'async_trait, T, B>(
    &'life0 mut self,
    query: B
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    T: Delete,
    B: Borrow<Query<T>> + Send + Sync,
    <Self as ToqlApi>::Error: From<ToqlError>,
    T: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,