Here’s how to add a Contract Test to a Go microservice, a provider in pact terminology, using pact-go This post uses v1 of pact-go, as the V2 version is stil in beta.
Install PACT cli tools on your dev machine
A linux or dev-container based environment can just use the same approach as the CI pipeline documented later on in this post.
For a Windows dev machine, install the pact-cli tools like this:
- Use browser to download
https://github.com/pact-foundation/pact-ruby-standalone/releases/download/v2.0.2/pact-2.0.2-windows-x86.zip - unzip to
c:\Repos - Change PATH to include
c:\repos\pact\bin - Restart any editors or terminals
- Run
go install gopkg.in/pact-foundation/pact-go.v1
Create a unit test to validate the service meets the contract/pact
Add unit test like below. Notice these settings and how the environment variables affect them. This helps when tests need to run both on the local development machine as well as on CI/CD machines.
| Setting | Effect |
|---|---|
| PublishVerificationResults | Controls if pact should publish the verification result to the broker. For my local dev machine I dont publish. From the CI pipeline I do publish |
| ProviderBranch | The name of the branch for this provider version. |
| ProviderVersion | The version of this provider. My CI pipeline ensures variable PACT_PROVIDER_VERSION contains the unique build number. On my local machine its just set to 0.0.0 |
package app
import (
"fmt"
"bff/itemrepository"
"os"
"strconv"
"strings"
"testing"
"github.com/pact-foundation/pact-go/dsl"
"github.com/pact-foundation/pact-go/types"
"github.com/stretchr/testify/assert"
)
func randomItem(env string, name string) itemrepository.item{
return itemrepository.item{
Environment: env,
Name: name,
}
}
func getEnv(name string, defaultVal string) string {
tmp := os.Getenv(name)
if len(tmp) > 0 {
return tmp
} else {
return defaultVal
}
}
func getProviderPublishResults() bool {
tmp, err := strconv.ParseBool(getEnv("PACT_PROVIDER_PUBLISH", "false"))
if err != nil {
panic(err)
}
return tmp
}
func TestProvider(t *testing.T) {
//Arrange: Start the service in the background.
port, repo, _ := startApp(false)
pact := &dsl.Pact{ Consumer: "MyConsumer", Provider: "MyProvider", }
//Act: Let pact spin-up a mock client to verifie our service.
_, err := pact.VerifyProvider(t, types.VerifyRequest{
ProviderBaseURL: fmt.Sprintf("http://localhost:%d", port),
BrokerURL: getEnv("PACT_BROKER_BASE_URL", ""),
BrokerToken: getEnv("PACT_BROKER_TOKEN", ""),
PublishVerificationResults: getProviderPublishResults(),
ProviderBranch: getEnv("PACT_PROVIDER_BRANCH", ""),
ProviderVersion: getEnv("PACT_PROVIDER_VERSION", "0.0.0"),
StateHandlers: types.StateHandlers{
"I have a list of items": func() error {
repo.Set("env1", []itemrepository.item{randomItem("env1", "tenant1")})
return nil
},
},
})
pact.Teardown()
//Assert
assert.NoError(t, err)
}
Ensure the CI pipeline runs the test and publishes verification results
For my CI builds, I run this to make sure the CI machine has the pact-cli tools installed
cd /opt
curl -fsSL https://raw.githubusercontent.com/pact-foundation/pact-ruby-standalone/master/install.sh | bash
export PATH=$PATH:/opt/pact/bin
go install github.com/pact-foundation/pact-go@v1
...
pipeline already runs the unit tests
...
Check `can-i-deploy` in the CD pipeline
Change the CD pipeline to
- verify this version of the service has passed the contract test, Otherwise do not deploy to production
- After successful deployment, inform broker which new version is running in production.
My CD pipeline runs on different machines, so it again has to ensure PACT is installed, just like the CI pipeline:
# pipeline variables
PACT_PACTICIPANT=MyProvider
PACT_ENVIRONMENT=production
PACT_BROKER=https://yourtenant.pactflow.io
PACT_BROKER_TOKEN=...a read/write token...preferably a system user to represent CI/CD actions...
# task to install PACT
cd /opt
curl -fsSL https://raw.githubusercontent.com/pact-foundation/pact-ruby-standalone/master/install.sh | bash
echo "##vso[task.prependpath]/opt/pact/bin"
...
...
# Task to check if the version of the build can be deployed to production
pact-broker can-i-deploy --pacticipant $PACT_PACTICIPANT --version $BUILD_BUILDNUMBER --to-environment $PACT_ENVIRONMENT --broker-base-url $PACT_BROKER --broker-token $PACT_BROKER_TOKEN
...
#Do whatever tasks you need to deploy the build to the environment
...
...
#Task to record the deployment of this version of the producer to the environment
pact-broker record-deployment --environment $PACT_ENVIRONMENT --version $BUILD_BUILDNUMBER --pacticipant $PACT_PACTICIPANT --broker-base-url $PACT_BROKER --broker-token $PACT_BROKER_TOKEN
