The document discusses using consumer-driven contract testing with Pact to test microservices. It outlines the benefits of consumer-driven contracts over traditional integration tests and dictator-driven contracts. It then provides an example of defining expectations between a consumer and provider using Pact, publishing and verifying the Pact contract. The presentation encourages learning more about Pact through its documentation and community resources.

1. Deploy with Confidence!
Deploy faster and safer using Pact
PRESENTED BY Matt Fellows (@matthewfellows)

2. Everyone is doing microservices

6. How do you test this?

7. “Integration tests are a scam”
- JB Rainsberger

8. Scam, you say? Justify!
Integrated tests are:
● Slow
● Fragile
● Hard to manage
When they fail, you can’t point to the problem!

9. Scam, you say? Justify!
“But my integration tests run in Docker, why can’t I use
them?”
- People

10. Scam, you say? Justify!
“Because Maths”
- Me

12. Branches per box vs test cases required
2 code branches = 128 tests
5 code branches = 78,125 tests
10 code branches = 10M tests

13. Good tests have the exact opposite properties

15. Dictator Driven Contracts

16. 1. Sit in ivory tower and postulate
2. Document perfect API (Swagger, API blueprint etc.)
3. Create said API
4. Publish said document to consumers
5. Repeat steps 1-4
How to: Dictator Driven Contracts

20. Dictator Consumer Driven Contracts

22. Benefits?

23. You’ll know when you break a consumer

24. You have a form of documentation

25. You can test things independently

26. Pact
www.pact.io

27. Evolved from combining these two principles

28. Step 1: Define Consumer expectations

29. Step 1: Define Consumer expectations
Step 2: Verify expectations on Provider

30. Start with a consumer test

31. Given “User A exists”
When I Receive “a GET request for user A”
With “these headers and query”
Respond with “200 OK”
And “User A’s details in the body”

32. Given “User A does not exist”
When I Receive “a GET request for user A”
Respond with “404 Not Found”

33. Example

34. // Create a Pact test runner, connecting to local Daemon
// NOTE: I tend to use TestMain(m *testing.M) to set this up!
pact := dsl.Pact{
Port: 6666,
Consumer: "My Consumer",
Provider: "My Provider",
}
// Shuts down Mock Service when done
defer pact.Teardown()

35. // Setup our expected interactions on the Mock Service.
pact.
AddInteraction().
Given("User billy exists").
UponReceiving("A request to login with user 'billy'").
WithRequest(dsl.Request{
Method: "POST",
Path: "/users/login",
Body: loginRequest,
}).
WillRespondWith(dsl.Response{
Status: 200,
Headers: map[string]string{
"Content-Type": "application/json",
},
Body: `
{
"user": {
"name": "billy"
}
}
`,
})

36. // Run the test and verify the interactions.
err := pact.Verify(func() error {
client := Client{
Host: fmt.Sprintf("http://localhost:%d", pact.Server.Port),
}
client.loginHandler(rr, req)
// Expect User to be set on the Client
if client.user == nil {
return errors.New("Expected user not to be nil")
}
return nil
})
if err != nil {
t.Fatalf("Error on Verify: %v", err)
}
// Write pact to file `<pwd>/pacts/my_consumer-my_provider.json`
// NOTE: This also is a good candidate for use in TestMain(m *testing.M)
pact.WritePact()

37. Next publish your pacts

38. // Publish the Pacts...
p := dsl.Publisher{}
err := p.Publish(types.PublishRequest{
PactURLs: []string{"../pacts/myconsumer-myprovider.json"},
PactBroker: os.Getenv("PACT_BROKER_HOST"),
ConsumerVersion: "1.0.0",
Tags: []string{"latest", "production"},
BrokerUsername: os.Getenv("PACT_BROKER_USERNAME"),
BrokerPassword: os.Getenv("PACT_BROKER_PASSWORD"),
})

39. Then verify your provider

40. // Verify the Provider from tagged Pact files stored in a Pact Broker
response = pact.VerifyProvider(types.VerifyRequest{
ProviderBaseURL: fmt.Sprintf("http://localhost:%d", providerPort),
BrokerURL: brokerHost,
Tags: []string{"latest", "prod"},
ProviderStatesURL: fmt.Sprintf("http://localhost:%d/states", providerPort),
ProviderStatesSetupURL: fmt.Sprintf("http://localhost:%d/setup", providerPort),
BrokerUsername: os.Getenv("PACT_BROKER_USERNAME"),
BrokerPassword: os.Getenv("PACT_BROKER_PASSWORD"),
})
if response.ExitCode != 0 {
t.Fatalf("Got %d, Want exit code 0", response.ExitCode)
}

41. Verifying a pact between billy and bobby
Given User billy exists
A request to login with user 'billy'
with POST /users/login
returns a response which
Setting up provider state 'User billy exists' for consumer 'billy' using provider state server at
http://localhost:55128/setup
has status code 200
has a matching body
includes headers
"Content-Type" with value "application/json"
Given User billy does not exist
A request to login with user 'billy'
with POST /users/login
returns a response which
Setting up provider state 'User billy does not exist' for consumer 'billy' using provider state server at
http://localhost:55128/setup
has status code 404
includes headers
"Content-Type" with value "application/json"
...
Finished in 0.03042 seconds
7 examples, 0 failures

42. Verifying a pact between billy and bobby
Given User billy exists
A request to login with user 'billy'
with POST /users/login
returns a response which
Setting up provider state 'User billy exists' for consumer 'billy' using provider state server at
http://localhost:55420/setup
has status code 200
has a matching body (FAILED - 1)
includes headers
"Content-Type" with value "application/json"
Failures:
1) Verifying a pact between billy and bobby Given User billy exists A request to login with user 'billy' with POST
/users/login returns a response which has a matching body
Failure/Error: expect(response_body).to match_term expected_response_body, diff_options
Actual: {"user":{"user":"billy"}}
@@ -1,6 +1,5 @@
{
"user": {
- "name": "billy"
}
}

43. Find out more
● Gitbook: docs.pact.io
● Github: pact-foundation/pact-go
● Google users group:
https://groups.google.com/forum/#!forum/pact-support
● Gitter: Join the chat at
https://gitter.im/realestate-com-au/pact
● Twitter: @pact_up

44. Thank you
- @matthewfellows
Given “The presentation is over”
Upon Receiving “A request for an answer”
With “A valid question”
Respond With “A valid answer”