Javascript

Pact JS is currently compliant to Pact Specification Version 2.0.

Quickstart guide (Consumer)

For a Consumer using Jest and node (for example, an app created with create-react-app):

First, you’ll need to add the Pact library:

  1. npm install --save-dev '@pact-foundation/pact'

Then, add the following script to your package.json:

  1.   scripts: {
  2.     ...
  3.     "pactTest":
  4.     "export NODE_ENV=pactTest && jest --testRegex \"/*(.test.pact.js)\" --runInBand --setupFiles ./pactSetup.js --setupTestFrameworkScriptFile ./pactTestWrapper.js"
  5.   }

You’ll also need to give Pact some metadata about your setup. This is done with pactSetup.js: 

  1. const path = require('path');
  2. const { Pact } = require('@pact-foundation/pact');
  4. global.port = 8989;
  5. global.provider = new Pact({
  6.   port: global.port,
  7.   log: path.resolve(process.cwd(), 'logs', 'mockserver-integration.log'),
  8.   dir: path.resolve(process.cwd(), 'pacts'),
  9.   spec: 2,
  10.   cors: true,
  11.   pactfileWriteMode: 'update',
  12.   consumer: /* the name of your consumer */,
  13.   provider: /* the name of your provider */
  14. });

Global setup for Jest is handled with pactTestWrapper.js:

  1. jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000; //* This is to give the pact mock server time to start
  3. beforeAll(() => provider.setup()); // Create mock provider
  4. afterEach(() => provider.verify()); // Ensure the mock provider verifies expected interactions for each test
  5. afterAll(() => provider.finalize()); // Tear down the mock and write the pact

Then you can write tests of the form <filename>.test.pact.js:

  1. import { Pact } from '@pact-foundation/pact';
  2. import { api } from /* wherever */;   // This is your client-side API layer
  5. describe('The API', () => {
  6.   let url = 'http://localhost';
  8.   // Copy this block once per interaction under test
  9.   describe(/* The API interaction being tested in words (string) */, () => {
  10.     beforeEach(() => {
  11.       const interaction = {
  12.         uponReceiving: /* Describe the request in words (string) */,
  13.         withRequest: {
  14.           method:  /* 'GET' or 'POST' or whatever (string) */,
  15.           path:  /* '/foo/bar' (string) */,
  16.           query:  /* '?query=parameters' (string) */,
  17.           headers: {
  18.             Accept: 'application/json'
  19.             /* etc */
  20.           }
  21.         },
  22.         willRespondWith: {
  23.           status: 200,
  24.           headers: {
  25.             'Content-Type': 'application/json'
  26.             /* etc */
  27.           },
  28.           body: /* describe the body (object using the Pact DSL)*/
  29.         }
  30.       };
  31.       return provider.addInteraction(interaction);
  32.     });
  34.     // add expectations
  35.     it(/* describe the test */, done => {
  36.       api(url).someCall()
  37.         .then(response => {
  38.           expect(response).toEqual(/* check the response here, using the default values provided to the Pact DSL */);
  39.         })
  40.         .then(done);
  41.     });
  42.   });  
  43. });

Once this is all setup, you can run your first pact test:

  1. $ npm run pactTest

If successful, this will produce a pact file in ./pacts/. If the test was unsuccessful, you can view detailed output in ./logs/mockserver-integration.log.

More information

If you need more information, the Pact JS readme has detailed information.

Additionally, these complete examples are useful guides: