- User declares contract between consumer and provider. Pact builder object is created.
builder {
serviceConsumer 'MessageConsumer'
hasPactWith 'MessageProvider'
}
- Using builder object, user sets up expectation of message using Pact DSL (message class is a Pact library object)
given:
builder {
given 'the provider has data for a message'
expectsToReceive 'a confirmation message for a group order'
withMetaData(contentType: 'application/json')
withContent {
name 'Bob'
date = '2000-01-01'
status 'bad'
age 100
}
- User executes tests showing that the consumer can handle the message correctly
builder.run { Message message ->
def content = new JsonSlurper().parse(message.contentsAsBytes())
// do something here that handles message
}
then:
true
- Builder merges message into pact file using provider state and description as the key (potentially call to pact ruby CLI to convert the simple ruby pact JSON into the proper message format?)
Q. What triggers the writing of the message?
-
Iterate through each message a) set up state b) invoke provider code that is expected to produce the message (argument is the message description) c) perform matching of expected/actual d) tear down state
-
Pass/fail based on overall state
Reuse pact-provider-verifier. Instead of user providing HTTP endpoints for the verifications and the state set up, they provide scripts.
eg.
pact-provider-verifier consumer-provider.json --provider-script provider.js --setup-script setup.js
Argument to the provider-script would be the message description. Argument to the setup-script would be either piped JSON (Q is this possible across platforms?) or key value pairs.
As for the consumer side, i'm not convinced this API is sufficient:
In the case of WebSockets, yes the interactions are asynchronous, but the response may go back to the original caller which needs to be correctly handled. In these cases, we need to capture the response else we risk breaking the original caller (hopefully without making /provider language is even more confusing!). It feels a bit clunky to have to setup both consumer and provider tests on both sides of this pipe for this interaction style.
WebSockets aside, any request/response style communication would fit into this sort of DSL e.g.
What if it looked something like this (in JS):
The key differences being the
addAsyncInteraction
to denote a different call type, and an optional response components (willRespondWith
andwithMetaData
) to compare what comes back.Am I missing something here?