Pact Go

Fast, easy and reliable testing for your APIs and microservices.

Documentation

This readme offers an basic introduction to the library. The full documentation for Pact Go and the rest of the framework is available at https://docs.pact.io/.

• Installation
• Consumer Testing
• Provider Testing
• Event Driven Systems
• Migration guide
• Troubleshooting

Tutorial (60 minutes)

Learn everything in Pact Go in 60 minutes: https://github.com/pact-foundation/pact-workshop-go

Need Help

• Join our community slack workspace.
• Stack Overflow: https://stackoverflow.com/questions/tagged/pact
• Say 👋 on Twitter: @pact_up

Installation

# install pact-go as a dev dependency
go get github.com/pact-foundation/pact-go/v2
# install CLI tools
go install github.com/pact-foundation/pact-go/v2

# download and install the required libraries. The pact-go will be installed into $GOPATH/bin, which is $HOME/go/bin by default. 
pact-go -l DEBUG install 

# 🚀 now write some tests!

If the pact-go command above is not found, make sure that $GOPATH/bin is in your path. I.e.,

export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

You can also keep the library versions up to date by running the version.CheckVersion() function.

Usage

Consumer package

The consumer interface is in the package: github.com/pact-foundation/pact-go/v2/consumer.

Writing a Consumer test

Pact is a consumer-driven contract testing tool, which is a fancy way of saying that the API Consumer writes a test to set out its assumptions and needs of its API Provider(s). By unit testing our API client with Pact, it will produce a contract that we can share to our Provider to confirm these assumptions and prevent breaking changes.

In this example, we are going to be testing our User API client, responsible for communicating with the UserAPI over HTTP. It currently has a single method GetUser(id) that will return a *User.

Pact tests have a few key properties. We'll demonstrate a common example using the 3A Arrange/Act/Assert pattern.

func TestUserAPIClient(t *testing.T) {
    // Specify the two applications in the integration we are testing
    // NOTE: this can usually be extracted out of the individual test for re-use)
    mockProvider, err := NewV2Pact(MockHTTPProviderConfig{
        Consumer: "UserAPIConsumer",
        Provider: "UserAPI",
    })
    assert.NoError(t, err)

    // Arrange: Setup our expected interactions
    mockProvider.
        AddInteraction().
        Given("A user with ID 10 exists").
        UponReceiving("A request for User 10").
        WithRequest("GET", S("/user/10")).
        WillRespondWith(200).
        WithBodyMatch(&User{})

    // Act: test our API client behaves correctly
    err = mockProvider.ExecuteTest(func(config MockServerConfig) error {
        // Initialise the API client and point it at the Pact mock server
        // Pact spins up a dedicated mock server for each test
        client := newClient(config.Host, config.Port)

        // Execute the API client
        user, err := client.GetUser("10")

        // Assert: check the result
        assert.NoError(t, err)
        assert.Equal(t, 10, user.ID)

        return err
    })
    assert.NoError(t, err)
}

You can see (and run) the full version of this in ./examples/basic_test.go.

For a full example, see the Pactflow terraform provider pact tests.

Provider package

The provider interface is in the package: github.com/pact-foundation/pact-go/v2/provider

Verifying a Provider

A provider test takes one or more pact files (contracts) as input, and Pact verifies that your provider adheres to the contract. In the simplest case, you can verify a provider as per below.

func TestV3HTTPProvider(t *testing.T) {
    // 1. Start your Provider API in the background
    go startServer()

    verifier := HTTPVerifier{}

    // Verify the Provider with local Pact Files
    // The console will display if the verification was successful or not, the
    // assertions being made and any discrepancies with the contract
    err := verifier.VerifyProvider(t, VerifyRequest{
        ProviderBaseURL: "http://localhost:1234",
        PactFiles: []string{
            filepath.ToSlash("/path/to/SomeConsumer-SomeProvider.json"),
        },
    })

    // Ensure the verification succeeded
    assert.NoError(t, err)
}

Compatibility

Roadmap

The roadmap for Pact and Pact Go is outlined on our main website. Detail on the native Go implementation can be found here.

Contributing

See CONTRIBUTING.