@pact-foundation/pact 7.3.0 → 8.0.2

package/README.md

@@ -33,16 +33,16 @@ Read [Getting started with Pact] for more information for beginners.
 
 - [Pact JS](#pact-js)
   - [Installation](#installation)
+    - [Do Not Track](#do-not-track)
   - [Using Pact JS](#using-pact-js)
   - [HTTP API Testing](#http-api-testing)
     - [Consumer Side Testing](#consumer-side-testing)
       - [API](#api)
-      - [Constructor Options](#constructor-options)
       - [Example](#example)
     - [Provider API Testing](#provider-api-testing)
       - [Verification Options](#verification-options)
       - [API with Provider States](#api-with-provider-states)
-      - [API with Authorization](#api-with-authorization)
+      - [Modify Requests Prior to Verification (Request Filters)](#modify-requests-prior-to-verification-request-filters)
     - [Publishing Pacts to a Broker](#publishing-pacts-to-a-broker)
       - [Publishing options](#publishing-options)
       - [Publishing Verification Results to a Pact Broker](#publishing-verification-results-to-a-pact-broker)
@@ -81,6 +81,21 @@ Read [Getting started with Pact] for more information for beginners.
 npm i -S @pact-foundation/pact@latest
 ```
 
+### Do Not Track
+
+In order to get better statistics as to who is using Pact, we have an anonymous tracking event that triggers when Pact installs for the first time. The only things we [track](https://github.com/pact-foundation/pact-node/blob/master/standalone/install.ts#L132-L143) are your type of OS, and the version information for the package being installed. No PII data is sent as part of this request. To respect your privacy, you can disable tracking by simply adding a 'do not track' flag within your package.json file or setting the environment variable `PACT_DO_NOT_TRACK=1`:
+
+```json
+{
+	"name": "some-project",
+	...
+	"config": {
+		"pact_do_not_track": true
+	},
+	...
+}
+```
+
 See the [Changelog] for versions and their history.
 
 ## Using Pact JS
@@ -94,13 +109,15 @@ Pact supports [synchronous request-response style HTTP interactions](#http-api-t
 To use the library on your tests, add the pact dependency:
 
 ```javascript
-const { Pact } = require("pact");
+const { Pact } = require("pact")
 ```
 
 The `Pact` class provides the following high-level APIs, they are listed in the order in which they typically get called in the lifecycle of testing a consumer:
 
 #### API
 
+<details><summary>Consumer API</summary>
+
 | API                 | Options                       | Returns   | Description                                                                                                                                                                                                                                                  |
 | ------------------- | ----------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `new Pact(options)` | See constructor options below | `Object`  | Creates a Mock Server test double of your Provider API. If you need multiple Providers for a scenario, you can create as many as these as you need.                                                                                                          |
@@ -109,7 +126,9 @@ The `Pact` class provides the following high-level APIs, they are listed in the
 | `verify()`          | n/a                           | `Promise` | Verifies that all interactions specified. This should be called once per test, to ensure your expectations were correct                                                                                                                                      |
 | `finalize()`        | n/a                           | `Promise` | Records the interactions registered to the Mock Server into the pact file and shuts it down. You would normally call this only once in an `afterAll(...)` type clause.                                                                                       |
 
-#### Constructor Options
+</details>
+
+<details><summary>Constructor</summary>
 
 | Parameter           | Required? | Type    | Description                                                                                              |
 | ------------------- | --------- | ------- | -------------------------------------------------------------------------------------------------------- |
@@ -127,6 +146,8 @@ The `Pact` class provides the following high-level APIs, they are listed in the
 | `cors`              | no        | boolean | Allow CORS OPTION requests to be accepted, defaults to false                                             |
 | `pactfileWriteMode` | no        | string  | Control how the Pact files are written. Choices: 'overwrite' 'update' or 'none'. Defaults to 'overwrite' |
 
+</details>
+
 #### Example
 
 The first step is to create a test for your API Consumer. The example below uses [Mocha](https://mochajs.org), and demonstrates the basic approach:
@@ -141,18 +162,15 @@ The first step is to create a test for your API Consumer. The example below uses
 Check out the `examples` folder for examples with Karma Jasmine, Mocha and Jest. The example below is taken from the [integration spec](https://github.com/pact-foundation/pact-js/blob/master/src/pact.integration.spec.ts).
 
 ```javascript
-/**
- * The following example is for Pact version 5
- */
-const path = require('path')
-const chai = require('chai')
-const { Pact } = require('@pact-foundation/pact')
-const chaiAsPromised = require('chai-as-promised')
+const path = require("path")
+const chai = require("chai")
+const { Pact } = require("@pact-foundation/pact")
+const chaiAsPromised = require("chai-as-promised")
 
-const expect = chai.expect;
-const MOCK_SERVER_PORT = 2202;
+const expect = chai.expect
+const MOCK_SERVER_PORT = 2202
 
-chai.use(chaiAsPromised);
+chai.use(chaiAsPromised)
 
 describe("Pact", () => {
   // (1) Create the Pact object to represent your provider
@@ -163,8 +181,8 @@ describe("Pact", () => {
     log: path.resolve(process.cwd(), "logs", "pact.log"),
     dir: path.resolve(process.cwd(), "pacts"),
     logLevel: "INFO",
-    spec: 2
-  });
+    spec: 2,
+  })
 
   // this is the response you expect from your Provider
   const EXPECTED_BODY = [
@@ -176,10 +194,10 @@ describe("Pact", () => {
         { id: 1, name: "Do the laundry", done: true },
         { id: 2, name: "Do the dishes", done: false },
         { id: 3, name: "Do the backyard", done: false },
-        { id: 4, name: "Do nothing", done: false }
-      ]
-    }
-  ];
+        { id: 4, name: "Do nothing", done: false },
+      ],
+    },
+  ]
 
   context("when there are a list of projects", () => {
     describe("and there is a valid user session", () => {
@@ -196,52 +214,56 @@ describe("Pact", () => {
               withRequest: {
                 method: "GET",
                 path: "/projects",
-                headers: { Accept: "application/json" }
+                headers: { Accept: "application/json" },
               },
               willRespondWith: {
                 status: 200,
                 headers: { "Content-Type": "application/json" },
-                body: EXPECTED_BODY
-              }
-            });
+                body: EXPECTED_BODY,
+              },
+            })
           })
-          .then(() => done());
-      });
+          .then(() => done())
+      })
 
       // (4) write your test(s)
-      it("should generate a list of TODOs for the main screen", () => {
-        const todoApp = new TodoApp();
+      it("generates a list of TODOs for the main screen", () => {
+        const todoApp = new TodoApp()
         todoApp
           .getProjects() // <- this method would make the remote http call
           .then(projects => {
-            expect(projects).to.be.a("array");
-            expect(projects).to.have.deep.property("projects[0].id", 1);
+            expect(projects).to.be.a("array")
+            expect(projects).to.have.deep.property("projects[0].id", 1)
 
             // (5) validate the interactions you've registered and expected occurred
             // this will throw an error if it fails telling you what went wrong
-            expect(provider.verify()).to.not.throw();
-          });
-      });
+            expect(provider.verify()).to.not.throw()
+          })
+      })
 
       // (6) write the pact file for this consumer-provider pair,
       // and shutdown the associated mock server.
       // You should do this only _once_ per Provider you are testing.
       after(() => {
-        return provider.finalize();
-      });
-    });
-  });
-});
+        return provider.finalize()
+      })
+    })
+  })
+})
 ```
 
 ### Provider API Testing
 
+<details><summary>Provider API</summary>
+
 Once you have created Pacts for your Consumer, you need to validate those Pacts against your Provider. The Verifier object provides the following API for you to do so:
 
 | API                |  Options  | Returns   | Description           |
 | ------------------ | :-------: | --------- | --------------------- |
 | `verifyProvider()` | See below | `Promise` | Start the Mock Server |
 
+</details>
+
 1.  Start your local Provider service.
 1.  Optionally, instrument your API with ability to configure [provider states](https://github.com/pact-foundation/pact-provider-verifier/)
 1.  Then run the Provider side verification step
@@ -259,47 +281,102 @@ new Verifier().verifyProvider(opts).then(function () {
 
 #### Verification Options
 
-| Parameter                   | Required | Type             | Description                                                                                                                                    |
-| --------------------------- | :------: | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| `providerBaseUrl`           |   true   | string           | Running API provider host endpoint. Required.                                                                                                  |
-| `provider`                  |   true   | string           | Name of the Provider. Required.                                                                                                                |
-| `pactUrls`                  |   true   | array of strings | Array of local Pact file paths or HTTP-based URLs (e.g. from a broker). Required if not using a Broker.                                      |
-| `pactBrokerUrl`             |  false   | string           | URL of the Pact Broker to retrieve pacts from. Required if not using pactUrls.                                                                 |
-| `tags`                      |  false   | array of strings | Array of tags, used to filter pacts from the Broker. Optional.                                                                                 |
-| `providerStatesSetupUrl`    |  false   | string           | Optional URL to call with a POST request for each `providerState` defined in a pact (see below for more info).
-| `pactBrokerUsername`        |  false   | string           | Username for Pact Broker basic authentication                                                                                                  |
-| `pactBrokerPassword`        |  false   | string           | Password for Pact Broker basic authentication                                                                                                  |
-| `publishVerificationResult` |  false   | boolean          | Publish verification result to Broker                                                                                                          |boolean
-| `providerVersion`           |  false   | string           | Provider version, required to publish verification results to a broker                                                                         |
-| `customProviderHeaders`     |  false   | array of strings | Header(s) to add to provider state set up and pact verification re`quests`. eg 'Authorization: Basic cGFjdDpwYWN0'.Broker. Optional otherwise. |
-| `timeout`                   |  false   | number           | The duration in ms we should wait to confirm verification process was successful. Defaults to 30000, Optional.                                 |
-
-That's it! Read more about [Verifying Pacts](https://docs.pact.io/getting_started/verifying_pacts).
+<details><summary>Verification Options</summary>
+
+| Parameter                   | Required | Type             | Description                                                                                                                                                                                                                                      |
+| --------------------------- | :------: | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `providerBaseUrl`           |   true   | string           | Running API provider host endpoint. Required.                                                                                                                                                                                                    |
+| `provider`                  |   true   | string           | Name of the Provider. Required.                                                                                                                                                                                                                  |
+| `pactUrls`                  |   true   | array of strings | Array of local Pact file paths or HTTP-based URLs (e.g. from a broker). Required if not using a Broker.                                                                                                                                          |
+| `pactBrokerUrl`             |  false   | string           | URL of the Pact Broker to retrieve pacts from. Required if not using pactUrls.                                                                                                                                                                   |
+| `tags`                      |  false   | array of strings | Array of tags, used to filter pacts from the Broker.                                                                                                                                                                                             |
+| `providerStatesSetupUrl`    |  false   | string           | DEPRECATED (see `stateHandlers`). URL to call with a POST request for each `providerState` defined in a pact (see below for more info).                                                                                                          |
+| `pactBrokerUsername`        |  false   | string           | Username for Pact Broker basic authentication                                                                                                                                                                                                    |
+| `pactBrokerPassword`        |  false   | string           | Password for Pact Broker basic authentication                                                                                                                                                                                                    |
+| `publishVerificationResult` |  false   | boolean          | Publish verification result to Broker                                                                                                                                                                                                            | boolean |
+| `providerVersion`           |  false   | string           | Provider version, required to publish verification results to a broker                                                                                                                                                                           |
+| `customProviderHeaders`     |  false   | array of strings | Header(s) to add to any requests to the provider service. eg `Authorization: Basic cGFjdDpwYWN0`. All interactions will receive the header. See `requestFilter` for when more flexiblility is required in modifying the request to the provider. |
+| `timeout`                   |  false   | number           | The duration in ms we should wait to confirm verification process was successful. Defaults to 30000.                                                                                                                                             |
+| `requestFilter`             |  false   | object           | An Express middleware handler (See https://expressjs.com/en/guide/writing-middleware.html) to modify requests and responses from the provider. See below for more details.                                                                       |
+| `stateHandlers`             |  false   | object           | Provider state handlers. A map of `string` -> `() => Promise`, where each string is the state to setup, and the function is used to configure the state in the Provider. See below for detail.                                                   |
+
+</details>
+
+Read more about [Verifying Pacts](https://docs.pact.io/getting_started/verifying_pacts).
 
 #### API with Provider States
 
-If you have defined any `state`s in your consumer tests, the `Verifier` can put the provider into the right state right before submitting a request (for example, the provider can use the state to mock away certain database queries). To support this, the provider must provide an extra API endpoint that accepts the query parameters `consumer` and `state` and returns an HTTP `200`.
+If you have defined any `state`s in your consumer tests, the `Verifier` can put the provider into the right state prior to sending the request. For example, the provider can use the state to mock away certain database queries. To support this, set up a handler for each `state` using hooks on the `stateHandlers` property. Here is an example from our [e2e suite](https://github.com/pact-foundation/pact-js/blob/master/examples/e2e/test/provider.spec.js):
+
+```js
+let opts = {
+  ...
+  stateHandlers: {
+    "Has no animals": () => {
+      animalRepository.clear()
+      return Promise.resolve(`Animals removed from the db`)
+    },
+    "Has some animals": () => {
+      importData()
+      return Promise.resolve(`Animals added to the db`)
+    },
+    "Has an animal with ID 1": () => {
+      importData()
+      return Promise.resolve(`Animals added to the db`)
+    }
+  }
+}
+
+return new Verifier(opts).verifyProvider().then(...)
+```
+
+As you can see, for each state ("Has no animals", ...), we configure the local datastore differently. If this option is not configured, the `Verifier` will ignore the provider states defined in the pact and log a warning.
+
+Read more about [Provider States](https://docs.pact.io/getting_started/provider_states).
 
-You can then configure this endpoint as `providerStatesSetupUrl` in the options passed into `Verifier.verifyProvider()`. If this option is not configured, the `Verifier` will ignore the provider states defined in the pact.
+#### Modify Requests Prior to Verification (Request Filters)
 
-See this [Provider](https://github.com/pact-foundation/pact-js/blob/master/examples/e2e/test/provider.spec.js) for a working example, or read more about [Provider States](https://docs.pact.io/getting_started/provider_states).
+Sometimes you may need to add things to the requests that can't be persisted in a pact file. Examples of these are authentication tokens with a small life span. e.g. an OAuth bearer token: `Authorization: Bearer 0b79bab50daca910b000d4f1a2b675d604257e42`.
 
-#### API with Authorization
+For these cases, we have two facilities that should be carefully used during verification:
 
-Sometimes you may need to add things to the requests that can't be persisted in a pact file. Examples of these would be authentication tokens, which have a small life span. e.g. an OAuth bearer token: `Authorization: Bearer 0b79bab50daca910b000d4f1a2b675d604257e42`.
+1. the ability to specify custom headers to be sent during provider verification. The flag to achieve this is `customProviderHeaders`.
+1. the ability to modify a request/response and modify the payload. The flag to achieve this is `requestFilter`.
 
-For this case, we have a facility that should be carefully used during verification - the ability to specificy custom headers to be sent during provider verification. The flag to achieve this is `customProviderHeaders`.
+**Example API with Authorization**
 
-For example, to have two headers sent as part of the verification request, modify the `verifyProvider` options as per below:
+For example, to have an `Authorization` bearer token header sent as part of the verification request, set the `verifyProvider` options as per below:
 
 ```js
+let token
 let opts = {
   provider: 'Animal Profile Service',
   ...
-  customProviderHeaders: ['Authorization: Bearer e5e5e5e5e5e5e5', 'SomeSpecialHeader: some specialvalue']
+  stateHandlers: {
+    "is authenticated": () => {
+      token = "1234"
+      Promise.resolve(`Valid bearer token generated`)
+    },
+    "is not authenticated": () => {
+      token = ""
+      Promise.resolve(`Expired bearer token generated`)
+    }
+  },
+
+  // this middleware is executed for each request, allowing `token` to change between invocations
+  // it is common to pair this with `stateHandlers` as per above, that can set/expire the token
+  // for different test cases
+  requestFilter: (req, res, next) => {
+    req.headers["Authorization"] = `Bearer: ${token}`
+    next()
+  },
+
+  // This header will always be sent for each and every request, and can't be dynamic
+  // (i.e. passing a variable instead of the bearer token)
+  customProviderHeaders: ["Authorization: Bearer 1234"]
 }
 
-return new Verifier().verifyProvider(opts).then(output => { ... })
+return new Verifier(opts).verifyProvider().then(...)
 ```
 
 As you can see, this is your opportunity to modify\add to headers being sent to the Provider API, for example to create a valid time-bound token.
@@ -312,13 +389,13 @@ Sharing is caring - to simplify sharing Pacts between Consumers and Providers, w
 
 The Broker:
 
-* versions your contracts
-* tells you which versions of your applications can be deployed safely together
-* allows you to deploy your services independently
-* provides API documentation of your applications that is guaranteed to be up-to date
-* visualises the relationships between your services
-* integrates with other systems, such as Slack or your CI server, via webhooks
-* ...and much much [more](https://docs.pact.io/getting_started/sharing_pacts).
+- versions your contracts
+- tells you which versions of your applications can be deployed safely together
+- allows you to deploy your services independently
+- provides API documentation of your applications that is guaranteed to be up-to date
+- visualises the relationships between your services
+- integrates with other systems, such as Slack or your CI server, via webhooks
+- ...and much much [more](https://docs.pact.io/getting_started/sharing_pacts).
 
 [Host your own](https://github.com/pact-foundation/pact_broker), or signup for a free hosted [Pact Broker](https://pact.dius.com.au).
 
@@ -335,15 +412,19 @@ pact.publishPacts(opts)).then(function () {
 
 #### Publishing options
 
-| Parameter            | Required | Type             | Description                                                                                           |
-| -------------------- | :------: | ---------------- | ----------------------------------------------------------------------------------------------------- |
-| `providerBaseUrl`    | `false`  | string           | Running API provider host endpoint.                                                   |
-| `pactFilesOrDirs`    | `true`   | array of strings | Array of local Pact files or directories containing pact files. Path must be absolute. Required.      |
-| `pactBroker`         | `true`   | string           | The base URL of the Pact Broker. eg. https://test.pact.dius.com.au. Required.                         |
-| `pactBrokerUsername` | `false`  | string           | Username for Pact Broker basic authentication. Optional                                               |
-| `pactBrokerPassword` | `false`  | string           | Password for Pact Broker basic authentication. Optional                                               |
-| `consumerVersion`    | `true`   | string           | The consumer application version; e.g. '1.0.0-cac389f'. ([See more info on versioning](https://docs.pact.io/getting_started/versioning_in_the_pact_broker)) |                |
-| `tags`               | `false`  | array of strings | Tag your pacts, often used with your branching, release or environment strategy e.g. ['prod', 'test'] |
+<details><summary>Publishing Options</summary>
+
+| Parameter            | Required | Type             | Description                                                                                                                                                 |
+| -------------------- | :------: | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `providerBaseUrl`    | `false`  | string           | Running API provider host endpoint.                                                                                                                         |
+| `pactFilesOrDirs`    |  `true`  | array of strings | Array of local Pact files or directories containing pact files. Path must be absolute. Required.                                                            |
+| `pactBroker`         |  `true`  | string           | The base URL of the Pact Broker. eg. https://test.pact.dius.com.au. Required.                                                                               |
+| `pactBrokerUsername` | `false`  | string           | Username for Pact Broker basic authentication. Optional                                                                                                     |
+| `pactBrokerPassword` | `false`  | string           | Password for Pact Broker basic authentication. Optional                                                                                                     |
+| `consumerVersion`    |  `true`  | string           | The consumer application version; e.g. '1.0.0-cac389f'. ([See more info on versioning](https://docs.pact.io/getting_started/versioning_in_the_pact_broker)) |  |
+| `tags`               | `false`  | array of strings | Tag your pacts, often used with your branching, release or environment strategy e.g. ['prod', 'test']                                                       |
+
+</details>
 
 #### Publishing Verification Results to a Pact Broker
 
@@ -393,18 +474,22 @@ From a Pact testing point of view, Pact takes the place of the intermediary (MQ/
 The following test creates a contract for a Dog API handler:
 
 ```js
-const { MessageConsumerPact, Message, synchronousBodyHandler } = require("@pact-foundation/pact");
+const {
+  MessageConsumerPact,
+  Message,
+  synchronousBodyHandler,
+} = require("@pact-foundation/pact")
 
 // 1 Dog API Handler
 const dogApiHandler = function(dog) {
   if (!dog.id && !dog.name && !dog.type) {
-    throw new Error("missing fields");
+    throw new Error("missing fields")
   }
 
   // do some other things to dog...
   // e.g. dogRepository.save(dog)
-  return;
-};
+  return
+}
 
 // 2 Pact Message Consumer
 const messagePact = new MessageConsumerPact({
@@ -412,12 +497,13 @@ const messagePact = new MessageConsumerPact({
   dir: path.resolve(process.cwd(), "pacts"),
   pactfileWriteMode: "update",
   provider: "MyJSMessageProvider",
-});
+})
 
 describe("receive dog event", () => {
-  it("should accept a valid dog", () => {
+  it("accepts a valid dog", () => {
     // 3 Consumer expectations
-    return (messagePact
+    return (
+      messagePact
         .given("some state")
         .expectsToReceive("a request for a dog")
         .withContent({
@@ -431,22 +517,22 @@ describe("receive dog event", () => {
 
         // 4 Verify consumers' ability to handle messages
         .verify(synchronousBodyHandler(dogApiHandler))
-    );
-  });
-});
+    )
+  })
+})
 ```
 
 **Explanation**:
 
 1.  The Dog API - a contrived API handler example. Expects a dog object and throws an `Error` if it can't handle it.
-    * In most applications, some form of transactionality exists and communication with a MQ/broker happens.
-    * It's important we separate out the protocol bits from the message handling bits, so that we can test that in isolation.
+    - In most applications, some form of transactionality exists and communication with a MQ/broker happens.
+    - It's important we separate out the protocol bits from the message handling bits, so that we can test that in isolation.
 1.  Creates the MessageConsumer class
 1.  Setup the expectations for the consumer - here we expect a `dog` object with three fields
 1.  Pact will send the message to your message handler. If the handler returns a successful promise, the message is saved, otherwise the test fails. There are a few key things to consider:
-    * The actual request body that Pact will send, will be contained within a [Message](https://github.com/pact-foundation/pact-js/tree/feat/message-pact/src/dsl/message.ts) object along with other context, so the body must be retrieved via `content` attribute.
-    * All handlers to be tested must be of the shape `(m: Message) => Promise<any>` - that is, they must accept a `Message` and return a `Promise`. This is how we get around all of the various protocols, and will often require a lightweight adapter function to convert it.
-    * In this case, we wrap the actual dogApiHandler with a convenience function `synchronousBodyHandler` provided by Pact, which Promisifies the handler and extracts the contents.
+    - The actual request body that Pact will send, will be contained within a [Message](https://github.com/pact-foundation/pact-js/tree/master/src/dsl/message.ts) object along with other context, so the body must be retrieved via `content` attribute.
+    - All handlers to be tested must be of the shape `(m: Message) => Promise<any>` - that is, they must accept a `Message` and return a `Promise`. This is how we get around all of the various protocols, and will often require a lightweight adapter function to convert it.
+    - In this case, we wrap the actual dogApiHandler with a convenience function `synchronousBodyHandler` provided by Pact, which Promisifies the handler and extracts the contents.
 
 ### Provider (Producer)
 
@@ -455,7 +541,7 @@ A Provider (Producer in messaging parlance) is the system that will be putting a
 As per the Consumer case, Pact takes the position of the intermediary (MQ/broker) and checks to see whether or not the Provider sends a message that matches the Consumer's expectations.
 
 ```js
-const { MessageProvider, Message } = require("@pact-foundation/pact");
+const { MessageProvider, Message } = require("@pact-foundation/pact")
 
 // 1 Messaging integration client
 const dogApiClient = {
@@ -464,37 +550,43 @@ const dogApiClient = {
       resolve({
         id: 1,
         name: "fido",
-        type: "bulldog"
-      });
-    });
-  }
-};
+        type: "bulldog",
+      })
+    })
+  },
+}
 
 describe("Message provider tests", () => {
   // 2 Pact setup
   const p = new MessageProviderPact({
     messageProviders: {
-      "a request for a dog": () => dogApiClient.createDog()
+      "a request for a dog": () => dogApiClient.createDog(),
     },
     provider: "MyJSMessageProvider",
     providerVersion: "1.0.0",
-    pactUrls: [path.resolve(process.cwd(), "pacts", "myjsmessageconsumer-myjsmessageprovider.json")],
-  });
+    pactUrls: [
+      path.resolve(
+        process.cwd(),
+        "pacts",
+        "myjsmessageconsumer-myjsmessageprovider.json"
+      ),
+    ],
+  })
 
   // 3 Verify the interactions
   describe("Dog API Client", () => {
-    it("should be a good Dog... message integration client", () => {
-      return p.verify();
-    });
-  });
-});
+    it("sends some dogs", () => {
+      return p.verify()
+    })
+  })
+})
 ```
 
 **Explanation**:
 
 1.  Our API client contains a single function `createDog` which is responsible for generating the message that will be sent to the consumer via some message queue
 1.  We configure Pact to stand-in for the queue. The most important bit here is the `messageProviders` block
-    * Similar to the Consumer tests, we map the various interactions that are going to be verified as denoted by their `description` field. In this case, `a request for a dog`, maps to the `createDog` handler. Notice how this matches the original Consumer test.
+    - Similar to the Consumer tests, we map the various interactions that are going to be verified as denoted by their `description` field. In this case, `a request for a dog`, maps to the `createDog` handler. Notice how this matches the original Consumer test.
 1.  We can now run the verification process. Pact will read all of the interactions specified by its consumer, and invoke each function that is responsible for generating that message.
 
 ### Pact Broker Integration
@@ -515,6 +607,8 @@ _NOTE: Make sure to start the mock service via the `Pact` declaration with the o
 
 Often times, you find yourself having to re-write regular expressions for common formats. We've created a number of them for you to save you the time:
 
+<details><summary>Matchers API</summary>
+
 | method                      | description                                                                                                                 |
 | --------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
 | `boolean`                   | Match a boolean value (using equality)                                                                                      |
@@ -530,22 +624,24 @@ Often times, you find yourself having to re-write regular expressions for common
 | `ipv6Address`               | Will match string containing IP6 formatted address                                                                          |
 | `uuid`                      | Will match strings containing UUIDs                                                                                         |
 
+</details>
+
 ### Match based on type
 
 ```javascript
-const { like } = Matchers;
+const { like } = Matchers
 
 provider.addInteraction({
   state: "Has some animals",
   uponReceiving: "a request for an animal",
   withRequest: {
     method: "GET",
-    path: "/animals/1"
+    path: "/animals/1",
   },
   willRespondWith: {
     status: 200,
     headers: {
-      "Content-Type": "application/json; charset=utf-8"
+      "Content-Type": "application/json; charset=utf-8",
     },
     body: {
       id: 1,
@@ -553,11 +649,11 @@ provider.addInteraction({
       address: like({
         street: "123 Smith St",
         suburb: "Smithsville",
-        postcode: 7777
-      })
-    }
-  }
-});
+        postcode: 7777,
+      }),
+    },
+  },
+})
 ```
 
 Note that you can wrap a `like` around a single value or an object. When wrapped around an object, all values and child object values will be matched according to types, unless overridden by something more specific like a `term`.
@@ -569,7 +665,7 @@ Note that you can wrap a `like` around a single value or an object. When wrapped
 Matching provides the ability to specify flexible length arrays. For example:
 
 ```javascript
-pact.eachLike(obj, { min: 3 });
+pact.eachLike(obj, { min: 3 })
 ```
 
 Where `obj` can be any javascript object, value or Pact.Match. It takes optional argument (`{ min: 3 }`) where min is greater than 0 and defaults to 1 if not provided.
@@ -577,7 +673,7 @@ Where `obj` can be any javascript object, value or Pact.Match. It takes optional
 Below is an example that uses all of the Pact Matchers.
 
 ```javascript
-const { somethingLike: like, term, eachLike } = pact;
+const { somethingLike: like, term, eachLike } = pact
 
 const animalBodyExpectation = {
   id: 1,
@@ -587,41 +683,41 @@ const animalBodyExpectation = {
   age: 21,
   gender: term({
     matcher: "F|M",
-    generate: "M"
+    generate: "M",
   }),
   location: {
     description: "Melbourne Zoo",
     country: "Australia",
-    post_code: 3000
+    post_code: 3000,
   },
   eligibility: {
     available: true,
-    previously_married: false
+    previously_married: false,
   },
-  children: eachLike({ name: "Sally", age: 2 })
-};
+  children: eachLike({ name: "Sally", age: 2 }),
+}
 
 // Define animal list payload, reusing existing object matcher
 // Note that using eachLike ensure that all values are matched by type
 const animalListExpectation = eachLike(animalBodyExpectation, {
-  min: MIN_ANIMALS
-});
+  min: MIN_ANIMALS,
+})
 
 provider.addInteraction({
   state: "Has some animals",
   uponReceiving: "a request for all animals",
   withRequest: {
     method: "GET",
-    path: "/animals/available"
+    path: "/animals/available",
   },
   willRespondWith: {
     status: 200,
     headers: {
-      "Content-Type": "application/json; charset=utf-8"
+      "Content-Type": "application/json; charset=utf-8",
     },
-    body: animalListExpectation
-  }
-});
+    body: animalListExpectation,
+  },
+})
 ```
 
 ### Match by regular expression
@@ -631,30 +727,30 @@ If none of the above matchers or formats work, you can write your own regex matc
 The underlying mock service is written in Ruby, so the regular expression must be in a Ruby format, not a Javascript format.
 
 ```javascript
-const { term } = pact;
+const { term } = pact
 
 provider.addInteraction({
   state: "Has some animals",
   uponReceiving: "a request for an animal",
   withRequest: {
     method: "GET",
-    path: "/animals/1"
+    path: "/animals/1",
   },
   willRespondWith: {
     status: 200,
     headers: {
-      "Content-Type": "application/json; charset=utf-8"
+      "Content-Type": "application/json; charset=utf-8",
     },
     body: {
       id: 100,
       name: "billy",
       gender: term({
         matcher: "F|M",
-        generate: "F"
-      })
-    }
-  }
-});
+        generate: "F",
+      }),
+    },
+  },
+})
 ```
 
 ## GraphQL API
@@ -673,19 +769,19 @@ Learn everything in Pact JS in 60 minutes: https://github.com/DiUS/pact-workshop
 
 ### HTTP APIs
 
-* [Complete Example (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/e2e)
-* [Pact with AVA (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/ava)
-* [Pact with Jest (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/jest)
-* [Pact with TypeScript + Mocha](https://github.com/pact-foundation/pact-js/tree/master/examples/typescript)
-* [Pact with Mocha](https://github.com/pact-foundation/pact-js/tree/master/examples/mocha)
-* [Pact with GraphQL](https://github.com/pact-foundation/pact-js/tree/feat/message-pact/examples/graphql)
-* [Pact with Karma + Jasmine](https://github.com/pact-foundation/pact-js/tree/master/karma/jasmine)
-* [Pact with Karma + Mocha](https://github.com/pact-foundation/pact-js/tree/master/karma/mocha)
+- [Complete Example (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/e2e)
+- [Pact with AVA (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/ava)
+- [Pact with Jest (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/jest)
+- [Pact with TypeScript + Mocha](https://github.com/pact-foundation/pact-js/tree/master/examples/typescript)
+- [Pact with Mocha](https://github.com/pact-foundation/pact-js/tree/master/examples/mocha)
+- [Pact with GraphQL](https://github.com/pact-foundation/pact-js/tree/master/examples/graphql)
+- [Pact with Karma + Jasmine](https://github.com/pact-foundation/pact-js/tree/master/karma/jasmine)
+- [Pact with Karma + Mocha](https://github.com/pact-foundation/pact-js/tree/master/karma/mocha)
 
 ### Asynchronous APIs
 
-* [Asynchronous messages](https://github.com/pact-foundation/pact-js/tree/feat/message-pact/examples/messages)
-* [Serverless](https://github.com/pact-foundation/pact-js/tree/feat/message-pact/examples/serverless)
+- [Asynchronous messages](https://github.com/pact-foundation/pact-js/tree/master/examples/messages)
+- [Serverless](https://github.com/pact-foundation/pact-js/tree/master/examples/serverless)
 
 ## Using Pact in non-Node environments
 
@@ -757,11 +853,11 @@ require.config({
   baseUrl: "/base",
   paths: {
     Pact: "node_modules/pact-web/pact-web",
-    client: "js/client"
+    client: "js/client",
   },
   deps: allTestFiles,
-  callback: window.__karma__.start
-});
+  callback: window.__karma__.start,
+})
 ```
 
 See this [Stack Overflow](https://stackoverflow.com/a/44170373/1008568) question for background, and
@@ -788,8 +884,8 @@ When all of your tests have completed, the result is the union of the all of the
 
 See the following examples for working parallel tests:
 
-* [Pact with AVA (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/ava)
-* [Pact with Mocha](https://github.com/pact-foundation/pact-js/tree/master/examples/mocha)
+- [Pact with AVA (Node env)](https://github.com/pact-foundation/pact-js/tree/master/examples/ava)
+- [Pact with Mocha](https://github.com/pact-foundation/pact-js/tree/master/examples/mocha)
 
 ### Splitting tests across multiple files
 
@@ -909,9 +1005,9 @@ Join us in [Slack](slack.pact.io)
 
 or chat to us at
 
-* Twitter: [@pact_up](https://twitter.com/pact_up)
-* Stack Overflow: https://stackoverflow.com/questions/tagged/pact
-* Google users group: https://groups.google.com/forum/#!forum/pact-support
+- Twitter: [@pact_up](https://twitter.com/pact_up)
+- Stack Overflow: https://stackoverflow.com/questions/tagged/pact
+- Google users group: https://groups.google.com/forum/#!forum/pact-support
 
 [getting started with pact]: http://dius.com.au/2016/02/03/microservices-pact/
 [v4]: https://github.com/pact-foundation/pact-js/tree/4.x.x