Struct lava_api_mock::SharedState

pub struct SharedState(_);

A thin wrapper around State for shared access.

Although a State can hold all the necessary data, it doesn’t define a strategy for sharing that data so it can be updated. Owing to limitations in the underlying crates this crate is based on, there’s only really one sensible way to do this at present, and that’s to use a CloneReplace to hold the data.

This is just a lightweight wrapper with some convenient methods to allow you to create wiremock endpoints. Those are in turn based on EndpointWithContext from django_query (specifically this is the WithContext variant, because the connections between the different data types are handled using persian-rug, and in fact a State is just a persian_rug::Context.

Implementations

impl SharedState

pub fn new() -> Self

Create and wrap a new empty State.

Example:

use lava_api_mock::SharedState;

let p = SharedState::new();

pub fn new_populated(pop: PopulationParams) -> Self

Create, populate and wrap a State.

pop is a PopulationParams instance giving a count for each type of object.

Example:

use lava_api_mock::SharedState;

let p = SharedState::new_populated(Default::default());

pub fn endpoint<T>(
    &self,
    uri: Option<&str>,
    default_limit: Option<usize>
) -> EndpointWithContext<CloneReplacePersianRugTableSource<impl Fn(&Arc<State>) -> TableIterator<'_, T> + Clone, State>>where
    T: Contextual<Context = State> + 'static,
    State: Owner<T>,

Create a new EndpointWithContext for type T within the enclosed State.

The return value is an implementor of wiremock::Respond and can be mounted directly onto a wiremock server instance.

Example:

use lava_api_mock::{Job, State, SharedState};

let p = SharedState::new();

let server = wiremock::MockServer::start().await;

wiremock::Mock::given(wiremock::matchers::method("GET"))
    .and(wiremock::matchers::path("/api/v0.2/jobs/"))
    .respond_with(p.endpoint::<Job<State>>(Some(&server.uri()), None))
    .mount(&server)
    .await;

pub fn nested_endpoint<T>(
    &self,
    params: NestedEndpointParams<'_>,
    default_limit: Option<usize>
) -> NestedEndpointWithContext<CloneReplacePersianRugTableSource<impl Fn(&Arc<State>) -> TableIterator<'_, T> + Clone, State>>where
    T: Contextual<Context = State> + 'static,
    State: Owner<T>,

Create a new NestedEndpointWithContext for type T within the enclosed State.

Nested endpoints objects data that can only be queried by providing some related object, like finding TestCase instances that match a given Job for example: here tests is nested under jobs. See the documentation for NestedEndpointWithContext for more details.

The return value is an implementor of wiremock::Respond and can be mounted directly onto a wiremock server instance.

Example:

use django_query::mock::{nested_endpoint_matches, NestedEndpointParams};
use lava_api_mock::{Job, State, SharedState, TestCase};

let p = SharedState::new();

let server = wiremock::MockServer::start().await;

wiremock::Mock::given(wiremock::matchers::method("GET"))
    .and(nested_endpoint_matches("/api/v0.2", "jobs", "tests"))
    .respond_with(p.nested_endpoint::<TestCase<State>>(
        NestedEndpointParams {
            root: "/api/v0.2",
            parent: "jobs",
            child: "tests",
            parent_query: "suite__job__id",
            base_uri: Some(&server.uri()),
        },
        Some(10),
    ))
    .mount(&server)
    .await;

pub fn access(&self) -> Arc<State>

Obtain a persian_rug::Accessor for the enclosed State

This permits reading the data contained in the State.

Example:

use lava_api_mock::{Job, SharedState};
use persian_rug::Accessor;

let p = SharedState::new_populated(Default::default());

for job in p.access().get_proxy_iter::<Job<_>>() {
    println!("Got job {:?}", p.access().get(&job));
}

pub fn mutate(&mut self) -> MutateGuard<State>

Obtain a persian_rug::Mutator for the enclosed State

This permits modifying the data contained in the State.

Example:

use boulder::{BuildableWithPersianRug, BuilderWithPersianRug};
use lava_api_mock::{Job, SharedState, State};
use persian_rug::Proxy;

let mut p = SharedState::new_populated(Default::default());

let _ = Proxy::<Job<State>>::builder().build(p.mutate());

Trait Implementations

impl Clone for SharedState

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for SharedState

fn default() -> Self

Returns the “default value” for a type.