Struct pact_consumer::prelude::PactBuilder

pub struct PactBuilder { /* private fields */ }

Builder for Pact objects.

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

let pact = PactBuilder::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 PactBuilder

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

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 Drop for PactBuilder

fn drop(&mut self)

Executes the destructor for this type.

impl StartMockServer for PactBuilder

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.

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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

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