You can find instructions for each language on the page.

    Here we have an example describing Pact tests between a consumer (the Zoo App), and its provider (the Animal Service).

    In the Consumer project, we’re going to need:

    • A model (the Alligator class) to represent the data returned from the Animal Service
    • A client (the AnimalServiceClient) which will be responsible for making the HTTP calls to the Animal Service.

    Note that to create a pact, you do need to write the code that executes the HTTP requests to your service (in your client class), but you don’t need to write the full stack of consumer code (eg. the UI).

    Ideally, the Pact tests should be “unit tests” for your client class, and they should just focus on ensuring that the request creation and response handling are correct. If you use pact for your UI tests, you’ll end up with an explosion of redundant interactions that will make the verification process tedious. Remember that pact is for testing the contract used for communication, and not for testing particular UI behaviour or business logic.

    1. Start with your model

    2. Create a skeleton Animal Service client class

    Perhaps we have an Animal Service client class that looks something like this (please excuse the use of httparty):

    2. class AnimalServiceClient
    3.   include HTTParty
    4.   base_uri 'http://animal-service.com'
    6.   def get_alligator
    7.     # Yet to be implemented because we're doing Test First Development...
    8.   end
    9. end

    3. Configure the mock Animal Service

    The following code will create a mock service on localhost:1234 which will respond to your application’s queries over HTTP as if it were the real Animal Service app. It also creates a mock provider object which you will use to set up your expectations. The method name to access the mock service provider will be what ever name you give as the service argument - in this case animal_service.

    1. # In /spec/service_providers/pact_helper.rb
    3. require 'pact/consumer/rspec'
    4. # or require 'pact/consumer/minitest' if you are using Minitest
    6. Pact.service_consumer "Zoo App" do
    7.   has_pact_with "Animal Service" do
    8.     mock_service :animal_service do
    9.       port 1234
    10.     end
    11. end

    4. Write a failing spec for the Animal Service client

    5. Run the specs

    Of course, the above specs will fail because the Animal Service client method is not implemented. No pact file has been generated yet because only interactions that were correctly executed will be written to the file, and we don’t have any of those yet.

    6. Implement the Animal Service client consumer methods

    1. class AnimalServiceClient
    2.   include HTTParty
    5.   def get_alligator
    6.     name = JSON.parse(self.class.get("/alligator").body)['name']
    7.     Alligator.new(name)
    8.   end
    9. end

    7. Run the specs again.

    Green!

    Running the passing AnimalServiceClient spec will generate a pact file in the configured pact dir (spec/pacts by default).
    Logs will be output to the configured log dir (log by default) that can be useful when diagnosing problems.

    You now have a pact file that can be used to verify your expectations of the Animal Service provider project.

    • 404 (return null, or raise an error?)
    • 400 (how should validation errors be handled, what will the body look like when there is one?)
    • 500 (specifying that the response body should contain an error message, and ensuring that your client logs that error message will make your life much easier when things go wrong. Note that it may be hard to force your provider to generate a 500 error on demand if you are not using Ruby. You may need to collaborate with your provider team to create a known provider state that will artificially return a 500 error, or you may just wish to use a standard unit test without a pact to test this.)
    • 401/403 if there is authorisation.

    1. Create the skeleton API classes

    Create your API class using the framework of your choice (the Pact authors have a preference for Webmachine and ) - leave the methods unimplemented, we’re doing Test First Develoment, remember?

    2. Tell your provider that it needs to honour the pact file you made earlier

    Require “pact/tasks” in your Rakefile.

    1. # In Rakefile
    2. require 'pact/tasks'

    Create a pact_helper.rb in your service provider project. The recommended place is spec/service_consumers/pact_helper.rb.

    For more information, see Verifying Pacts and the provider configuration documentation for your Pact implementation language (if you are following this example, here is the ).

    3. Run your failing specs

    Congratulations! You now have a failing spec to develop against.

    At this stage, you’ll want to be able to run your specs one at a time while you implement each feature. At the bottom of the failed pact:verify output you will see the commands to rerun each failed interaction individually. A command to run just one interaction will look like this:

    1. $ rake pact:verify PACT_DESCRIPTION="a request for an alligator" PACT_PROVIDER_STATE="an alligator exists"

    4. Implement enough to make your first interaction spec pass

    5. Keep going til you’re green

    Yay! Your Animal Service provider now honours the pact it has with your Zoo App consumer. You can now have confidence that your consumer and provider will play nicely together.