Struct pact_consumer::builders::PactBuilderAsync

pub struct PactBuilderAsync { /* private fields */ }

Builder for Pact objects (async version).

use pact_consumer::prelude::*;
use pact_consumer::*;

let pact = PactBuilderAsync::new("Greeting Client", "Greeting Server")
    .interaction("asks for a greeting", "", |mut i| async move {
        i.request.path("/greeting/hello");
        i.response
            .header("Content-Type", "application/json")
            .json_body(json_pattern!({ "message": "hello" }));
        i
    })
    .await
    .build();

// The request method and response status default as follows.
assert_eq!(pact.interactions()[0].as_request_response().unwrap().request.method, "GET");
assert_eq!(pact.interactions()[0].as_request_response().unwrap().response.status, 200);

Implementations

impl PactBuilderAsync

pub fn new<C, P>(consumer: C, provider: P) -> Self

where C: Into<String>, P: Into<String>,

Create a new PactBuilder, specifying the names of the service consuming the API and the service providing it.

pub fn new_v4<C, P>(consumer: C, provider: P) -> Self

where C: Into<String>, P: Into<String>,

Create a new PactBuilder for a V4 specification Pact, specifying the names of the service consuming the API and the service providing it.

pub async fn using_plugin( &mut self, name: &str, version: Option<String>, ) -> &mut Self

Add a plugin to be used by the test. This requires the plugins feature.

Panics: Plugins only work with V4 specification pacts. This method will panic if the pact being built is V3 format. Use PactBuilder::new_v4 to create a builder with a V4 format pact.

pub async fn interaction<D, F, O>( &mut self, description: D, interaction_type: D, build_fn: F, ) -> &mut Self

where D: Into<String>, F: FnOnce(InteractionBuilder) -> O, O: Future<Output = InteractionBuilder> + Send,

Add a new HTTP Interaction to the Pact. Needs to return a clone of the builder that is passed in.

pub fn push_interaction(&mut self, interaction: &dyn Interaction) -> &mut Self

Directly add a pre-built Interaction to our Pact. Normally it’s easier to use interaction instead of this function.

pub fn build(&self) -> Box<dyn Pact + Send + Sync>

Return the Pact we’ve built.

pub fn output_dir<D: Into<PathBuf>>(&mut self, dir: D) -> &mut Self

Sets the output directory to write pact files to

pub async fn message_interaction<D, F, O>( &mut self, description: D, build_fn: F, ) -> &mut Self

where D: Into<String>, F: FnOnce(MessageInteractionBuilder) -> O, O: Future<Output = MessageInteractionBuilder> + Send,

Add a new Asynchronous message Interaction to the Pact. Needs to return a clone of the builder that is passed in.

pub async fn synchronous_message_interaction<D, F, O>( &mut self, description: D, build_fn: F, ) -> &mut Self

where D: Into<String>, F: FnOnce(SyncMessageInteractionBuilder) -> O, O: Future<Output = SyncMessageInteractionBuilder> + Send,

Add a new synchronous message Interaction to the Pact. Needs to return a clone of the builder that is passed in.

pub fn messages(&self) -> MessageIterator<AsynchronousMessage>

Returns an iterator over the asynchronous messages in the Pact

pub fn synchronous_messages(&self) -> MessageIterator<SynchronousMessage>

Returns an iterator over the synchronous req/res messages in the Pact

Trait Implementations

impl Debug for PactBuilderAsync

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

Formats the value using the given formatter.

impl Drop for PactBuilderAsync

fn drop(&mut self)

Executes the destructor for this type.

impl StartMockServer for PactBuilderAsync

fn start_mock_server( &self, _catalog_entry: Option<&str>, ) -> Box<dyn ValidatingMockServer>

Start a mock server running in a background thread. If the catalog entry is omitted, then a standard HTTP mock server will be started.

impl StartMockServerAsync for PactBuilderAsync

fn start_mock_server_async<'life0, 'life1, 'async_trait>( &'life0 self, _catalog_entry: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Box<dyn ValidatingMockServer>> + Send + 'async_trait>>

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

Start a mock server running in a task (requires a Tokio runtime to be already setup)