Struct KubernetesMocker

pub struct KubernetesMocker { /* private fields */ }

The main mocker struct. Holds all the information about expected API calls, and provides functionality to set up expected requests and responses before testing with .run().

Implementations

impl KubernetesMocker

pub async fn expect<'a, Fut, T, F>( &mut self, expected_api_call: F, result: MockReturn<'a, T>, ) -> Result<&mut Self, MockError>

where Fut: Future<Output = ()> + Send, T: Resource + Serialize + Clone, F: FnOnce() -> Fut,

mocker.expect() - takes a closure producing a future and what to return when receiving the API call given by the closure. Each closure should only have 1 API call. More will be ignored, fewer will return an error.

Will return an error on panic, timeout, or if the closure does not make a request - feel free to use unwrap() liberally!

Returns Ok(&mut self) on success, meaning you can chain .expect().await.unwrap().expect().await.unwrap()…

Errors

• MockError::Serde - serde_json failed to serialize mock response
• MockError::NoRequest - closure passed in did not make an API request.
• MockError::Timeout - closure passed in timed out.
• MockError::Panicked - closure passed in panicked.
• MockError::WatchNoItems - Watch events list must contain at least one WatchEvent.
• MockError::HttpBody - failed to create an http::Response from the serialized bytes.

Examples

let (client, mut mocker) = make_mocker();
let api: Api<Node> = Api::all(client);
mocker.expect(|| async {
      api.list(&ListParams::default()).await.unwrap();
    },
    MockReturn::List(&[Node::default()]),
  ).await.unwrap()
  .expect(|| async {
      api.create(&PostParams::default(), &Node::default()).await.unwrap();
    },
    MockReturn::Single(Node::default()),
  ).await.unwrap();

pub async fn run(self) -> Result<(), MockRunError>

KubernetesMocker::run() - produces a future which will compare the received API calls past this point, and compare them to the ones received during the expect() calls.

Errors

• MockRunError::TooFewApiCalls - it did not receive as many API calls as expect() got.
• MockRunError::TooManyApiCalls - received at least 1 more API call that was not expected.
• MockRunError::IncorrectApiCall - an API call did not match the one received in the corresponding expect() call.

Should be run with tokio::task::spawn so it runs concurrently with whatever is being tested.

Examples

See examples for make_mocker().

Panics

Should not panic, if an HTTP body fails to be made it should be presented as an error during expect(). Still uses unwrap() for brevity, and to avoid a duplicate of MockError::HttpBody in MockRunError.