Struct pact_consumer::builders::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| {
        i.request.path("/greeting/hello");
        i.response
            .header("Content-Type", "application/json")
            .json_body(json_pattern!({ "message": "hello" }));
        i
    })
    .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_v3_message<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. This creates a V3 message pact, and only message interactions can be added.

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 fn with_output_dir<P: Into<PathBuf>>(&mut self, dir: P) -> &mut Self

Sets the output directory to write any pact files to. If this is not set, will default to the PACT_OUTPUT_DIR environment variable. If that is not set, will use the target directory.

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

Add a plugin to be used by the test. Note this will return an async version of the Pact builder and requires the plugin crate 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 fn interaction<D, F>( &mut self, description: D, interaction_type: D, build_fn: F, ) -> &mut Self

where D: Into<String>, F: FnOnce(InteractionBuilder) -> InteractionBuilder,

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 + Send + Sync + RefUnwindSafe), ) -> &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 + RefUnwindSafe>

Return the Pact we’ve built.

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

👎Deprecated: Use with_output_dir

Sets the output directory to write pact files to

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

where D: Into<String>, F: FnOnce(MessageInteractionBuilder) -> MessageInteractionBuilder,

Add a new Asynchronous message Interaction to the Pact

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

where D: Into<String>, F: FnOnce(SyncMessageInteractionBuilder) -> SyncMessageInteractionBuilder,

Add a new synchronous message Interaction to the Pact

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

Returns an iterator over the asynchronous messages in the Pact

pub fn v3_messages(&self) -> MessageIterator<Message>

Returns an iterator over the asynchronous messages in a V3 Message 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 PactBuilder

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

Formats the value using the given formatter.

impl StartMockServer for PactBuilder

fn start_mock_server( &self, _catalog_entry: Option<&str>, mock_server_config: Option<MockServerConfig>, ) -> 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.