31 posts tagged with "pact"

🕸️ Welcome to the October Pact Blog - hope you've got your 🎃 ready for carving, but for now, sit back and relax as we take you through all the updates in the Pact ecosystem along with events & material you've been sharing across the web this month.

Pact OSS Updates​

Pact Slack now has over 6 thousand members​

We are really proud to say we have just crossed the 6k mark, with 6005 members in our general channel in Pact Slack.

We appreciate many users journeys through Slack are transient, either whilst they are getting started with the Pact ecosystem, or after some help, and encounters may be all but fleeting. It is worth noting that not an insignificant amount of us have had the good fortune of meeting new friends, both in person, and virtually, making professional relationships and providing springboards to new opportunities. Some of the interactions have had positive life-changing impacts, your authors journey included.

We are proud to be able to foster a safe environment, where people are welcome to discuss contract testing with a captive audience, and for every engineer who finds that eureka moment where contract testing, just clicks, we know it is improving the API delivery landscape massively and has a net benefit to many interactions we have in our day-to-day life with systems.

If you are proud about the positive impacts Pact has had in your place of work, why not share it with the world? We can provide you a platform, and sharing your engineering mistakes and successes, is a great way to build transparency and trust with your customers, and promote a healthy learning based culture in your organisation.

Pact Message Workshops​

We've recently been working on a suite of Pact Message based examples, to show you how to test asynchronous systems with Pact, by concentrating on the messages sent between systems, rather than the underlying queuing system that transmits them.

We've taken PactFlow's kafka e2e example (consumer/provider), based on our common Product domain example and built out a suite of examples, in various Pact client DSL's.

You can find the new workshop over on GitHub pact-foundation/pact-workshop-message where you can see the Pact message concepts demonstrated in the following flavours.

• Pact-JS
• Pact-JVM
• Pact-Net
• Pact-Go
• Pact-Python
• Pact-Rust

We hope to build out a tutorial on the website, and further enhance it by adding synchronous message examples as well in the near future.

Pact RFCs​

We still have two RFC's currently awaiting review, why not take a look and add your review in the spirit of collaboration and open-source. The proposers would really appreciate and value your input.

1. rfc: configuration and shared files proposed by @JP-Ellis
2. rfc: Define matching rules for form-urlencoded body by @tienvx

Pact-Plugins​

Have you written a Pact plugin, or used one yet? We've seen a few community members create some, here are some that I've found.

• pact-avro-plugin written in Kotlin
• pact-avro-plugin written in GoLang
• avro-schema-as-pact-contract-plugin written in Kotlin

If you haven't and want to try it out, why not follow our Pact Plugin course, where you will learn the basics and get to build you own Plugin with templates we've provided to help you out.

If you fancy building one in a different language, I've created a suite of examples which you could use as a basis for your own project. Check them out here in my Pluginopedia.

Pact-Plugins - Slack​

Chat with us in: #pact-plugins.

Pact-JS​

James Gauld has been working on a couple of fixes in the Pact-JS lifecycle hooks.

• fix: support async afterEach hook
• fix: allow hooks to run only once per interaction

Pact-JS - Slack​

Chat with us in: #pact-js

Pact-Python​

Pact-Python 2.2.2 was released, which included initial support for matchers in the Pact V3 interface.

Check out the example test, for sample usage.

Pact-Python - Slack​

Chat to us in: #pact-python.

Pact-PHP​

Tien has been reworking some of the examples in the Pact-PHP repo, and adding more features, with more Pact generators, as defined in the V3/V4 Spec, including supporting the fromProviderState generator for advanced use-cases.

Why not try them out?

Pact-PHP - Slack​

Chat to us in: #pact-php.

Pact Broker​

• Stanislav provided another PR to the Pact Broker ecosystem, this time adding the --ignore <PACTICIPANT> flag to the pact-broker cli's can-i-merge command in this PR

• Want to run a Pact Broker in Azure? Ian Crowl provided this addition to the docs, which still requires a bit of work,but might be enough to get you started!

Pact-Broker - Slack​

Chat to us in: #pact-broker.

Pact Net​

Pact-Net V5 has now been released. It contains several fixes and features, including leveraging the latest pact ffi 0.4.23

If you want to leverage the Pact V4 Specification, which will allow you to have multiple interaction types in a single Pact file, you should upgrade now, and a great place to start is the upgrade guide.

If you prefer learning by example, the workshops have been updated to use the latest Pact V5 release.

• https://github.com/pact-foundation/pact-workshop-dotnet
• https://github.com/pact-foundation/pact-workshop-dotnet-core-v1

As well as the E2E examples

• https://github.com/pactflow/example-consumer-dotnet
• https://github.com/pactflow/example-provider-dotnet

You can check out the PR history, to see the delta for the migration from Pact-Net V4->V5.

Pact-Net - Slack​

Chat to us in: #pact-net.

Community Events​

Are you talking about Pact or contract-testing this year at an event? Why not let us know and get yourself featured!

Lewis Prescott - Reliable End to End Testing with API Contracts using Cypress & PactFlow​

Lewis recently took to the stage at CypressConf to teach users about the fundamentals of contract testing as well as how to implement consumer-driven contract testing with Cypress + Pactflow.

Murat K Ozcan - A triple whammy of contract testing posts​

Murat penned another post, this time looking at Pact Message. It's backed by examples in GitHub and well worth a read/look.

• Solving Cross-Execution Issues in Pact Testing with Kafka and Message Queues

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 6k other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

👋🏽 Welcome to the September Pact Blog, where we'll be covering all the updates in the Pact ecosystem along with events & material you've been sharing across the web.

Pact OSS Updates​

Pact RFCs​

We have two RFC's currently awaiting review, why not take a look and add your review in the spirit of collaboration and open-source. The proposers would really appreciate and value your input.

1. rfc: configuration and shared files proposed by @JP-Ellis
2. rfc: Define matching rules for form-urlencoded body by @tienvx

Pact-Plugins​

Back in March, we mentioned an issue when leveraging the Pact-Plugin framework with Pact-Go.

I'm pleased to say that the fix in the pact-plugins repo, was accepted and merged, to change the loading mechanism for plugins, from Tokio tasks, to System threads.

Pact-Plugins - Slack​

Chat with us in: #pact-plugins.

Pact-JS​

Pact-JS-CLI is now smaller, and leaner, with os/arch specific npm packages created for all supported platforms, thanks to this PR. The resolution for packages should be invisible to the end user, resulting in smaller downloads, and less disk-space being used by redundant files.

Available from V16.x - See the release notes for more detail

$ npx --package=@pact-foundation/pact-cli -c 'pact-broker version'
1.76.1

Want to see the same change in pact-js-core? Why not let us know!

Pact-JS - Slack​

Chat with us in: #pact-js

Pact-Go​

The pact-plugin update to switch from tokio tasks, to system threads was accepted, which allowed us to add the change to Pact-Go, hopefully fixing random panics during plugin based tests, highlighted in this issue.

Initial feedback is really positive. If you had this issue before, and it now appears to be resolved, why not let us know?

CGO or not to CGO? - In an infamous post by Dave Cheney, he mentions cgo is not go, and the mandatory requirement of cgo, in pact-go v2 has caused some users issues in initial setup. We have the potential to mitigate this requirement, by leveraging a project called ebitengine/purego, which describes itself as a library for calling C functions from Go, without Cgo. You can track the issue and associated pull request, to find out more.

Alpine Linux - We've been trying to get Pact working across alpine, natively, for all of our supported client languages, GoLang included. Follow the progress here. We are blocked at the moment due to some segfaults during the verification process and would appreciate any extra eyes, if this feature enhancement would be useful to you.

Pact-Go - Slack​

Chat with us in: #pact-go.

Pact-Python​

Some examples using the Pact-Python V3 interface, have now been included in the repo, thanks to Amit S in this PR.

Val Kolovos is also working on a Matcher proof of concept here in order to try and complete this open issue to Implement a Matcher interface, it has just been merged, but is awaiting the release of Python 3.14 (which has been delayed by a few days), before it will be released, however you can build the project locally to try out Val's changes today.

Pact-Python - Slack​

Chat to us in: #pact-python.

Pact-PHP​

Tien has began some incremental improvements in Pact-PHP V10, now that that v10 is now GA.

Two notable additions include

• feat: All custom provider headers
• feat: Add graphql example

These changes are currently on the master branch and unreleased, so will require to use the dev-master version if you want to pick them up.

Pact-PHP - Slack​

Chat to us in: #pact-php.

Pact Ruby​

@trammel submitted a PR to remove webrick from a dependency to a dev-dep over in pact-ruby, however it will need pact_mock-service to be updated to use an alternative over webrick, and to be able to drop it as a runtime dependency completely. If anyone fancies attempting this, please let us know.

Webrick suffered a round of CVE's recently, so the Pact ruby ecosystem has been updated (pact-ruby-cli, pact-ruby-standalone, pact-broker).

Sbmt-Pact - Pact V3/V4 & Plugin Support​

The Kuper development team recently announced an open-source ruby gem, called sbmt-pact, which builds on the pact-ffi ruby wrapper gem I created.

Yuri, a Senior developer at Cooper, has created a comprehensive blog post (note: written in Russian, so you may need to use your favourite translator) which covers lots of points

1. general principle of operation of contract tests;
2. about the problems we encountered when implementing contract testing and how we solved them;
3. how we developed our solution for contract testing of Ruby applications;
4. about setting up CI/CD to automate contract tests.

I would wholly recommend reading the article especially as it also explains why sbmt-pact came to be

1. the official ruby ​​gem only supported V1/V2 specifications, which only allow testing of http interactions;
2. the grpc/kafka interactions we need are supported in the V3/V4 specifications;
3. a little earlier, in the process of evolution and support of V3/V4 specifications, pact-foundation decided to rework the architecture and switched to shared rust-core , which assumes that test libraries for different stacks use FFI (foreign-function interface) as a single interface for interacting with the core in rust;
4. the official ruby ​​gem remained in limbo for a long time and was not developed, in parallel pact-ruby-ffi was created , providing a low-level interface to pact-core;
5. and only recently plans have emerged to develop an official ruby ​​gem and support V3/V4 - see Pact V3 Tracking Issue and Pact V4 Tracking Issue .

I particularly like these two quotes from the summary

Pact turned out to be not just a framework, but an entire ecosystem ready for any challenges of modern microservice architecture. With support for various languages ​​and protocols, it becomes an indispensable ally in the fight for code quality.

and

Ruby developers are especially pleased: even when official support lags behind, the community will always find a way out. Our experience with sbmt-pact is a vivid confirmation of this. This once again proves that there are no unsolvable problems in the open-source world.

I totally agree with you Yuri. 🙌

Why not try out sbmt-pact, and give the authors some feedback?

Pact-Ruby - Slack​

Chat to us in: #pact-ruby.

Pact Broker​

The Pact Broker image was updated to leverage Ruby 3.3.5 in v2.122.0.

Pact Broker Chart​

Shane Hull added the ability to set svc annotations, check out his PR here. It was merged and released this month.

Pact-Broker - Slack​

Chat to us in: #pact-broker.

Pact Net​

Pact-Net V5 Beta 3 has now been released. It contains several fixes and features, including leveraging the latest pact ffi 0.4.23

V5 of pact-net is considered to be pretty stable, and is being used in a few production workflows and we expect it to become GA very soon. If you want to leverage the Pact V4 Specification, which will allow you to have multiple interaction types in a single Pact file, you should upgrade now!

Pact-Net - Slack​

Chat to us in: #pact-net.

Community Events​

Are you talking about Pact or contract-testing this year at an event? Why not let us know and get yourself featured!

Murat K Ozcan - A triple whammy of contract testing posts​

Murat has recently been taking an adventure in the world of Pact, after picking up Marie & Lewis' Contract testing in Action book. He has written 3 posts which are well worth a read.

• My thoughts and notes about Consumer Driven Contract Testing
• Strengthening Pact Contract Testing with TypeScript and Data Abstraction
• Handling Pact Breaking Changes Dynamically in CI/CD

Pact & AI​

Generative AI, has become a dining room table topic and you may be wondering how it may impact the world of contract testing.

Both Matt and I take you through a 3-part journey, where we explore the importance of contract testing, the potential of Generative AI, and how PactFlow have turned a concept into reality, harnessing the power of GenAI, Pact best practice, and up to date knowledge of our consumer DSL's in order to allow you to unlock the value potential of contract testing sooner.

• The Case for Contract Testing: Cutting Through API Integration Complexity
• Unpacking GenAI’s Role in Contract Testing
• Bridging Development Gaps with AI-Augmented Contract Testing

Pact & AsyncAPI​

The PactFlow team support a tool, called swagger-mock-validator, which allows you to compare a Pact file containing HTTP interactions, against an OpenAPI document. Originally created by Atlassian, it opened up broader use-cases than the traditional consumer driven approach with Pact, of replaying the interactions against a running provider, however does not offer as strong a guarantee, as it is reliant on the actual implemented provider, not drifting from the api description that is presented to consumers.

Whilst provider drift, is something that the industry has not fully addressed, (the ability to ensure a provider implementation completely honours its API description), the demand for static comparison tools to compare Pact files, is still there.

There is potential to couple both approaches, using API design documents as central points of truth. Using Pacts powerful DSL to generate consumer contracts. Using static comparison tools to ensure they honour the API description. If they differ, a proposal must be made in the documentation to reflect this. Pact plays a role in the verification of the provider, by replaying the Pact interactions, it mitigates provider drift from the consumer contract perspective, which with a static comparison tool, has been proven to adhere to the API description, eliminating provider drift for the known consumed endpoints in use.

Maybe in the future, we will see Pact being API description aware, in order to verify the implementation adheres to the API description.

However in the interim, one of the most requested comparison features, was Pact vs AsyncAPI.

AsyncAPI, for those who are unaware, is an API description format that covers event-driven systems, which consume or send messages, with a particular content format. The messages themselves may be transmitted over any number of different protocols, described as bindings in the AsyncAPI.

Message Pact, allows for the contract testing of service messages, without being interested in how the messages themselves are transmitted.

A recent introduction to the Pact ecosystem, exposed a plugin mechanism, which allows users to create their own custom content-type matcher & transport capabilities, which allows Pact users to consider content-types and transport capabilities not currently available in Pact, but leveraged in AsyncAPI based descriptions.

In order to try and progress momentum in providing a way to users to leverage AsyncAPI in their Pact journeys, I have created pact-asyncapi-comparator.

npx pact-asyncapi-comparator <Pact File Location> <AsyncAPI File Location>

It will allow for the comparison of application/json message content, in a V3 or V4 specification Pact file, against a valid AsyncAPI 2.x/3.x document.

I'd love for message pact users, to give it a go, and if it doesn't cover your use case, let me know in the issues section.

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 5.8K other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

👋🏽 Welcome to the August Pact Blog, where we'll be covering all the updates in the Pact ecosystem along with events & material you've been sharing across the web.

Pact OSS Updates​

General Updates​

Pact RFC Process​

We mentioned an RFC process being introduced into the Pact ecosystem, last month, I'm pleased to say the PR has been merged, so I would invite users to begin to raise new RFC's where appropriate as we would love users to participate and help shape the future of Pact you want to see.

Specific language updates​

Pact-Reference​

Max Campman dropped a PR here to allow non-object matchers for array-contains.

Whilst Ron performed few fixes and incorporated the v2 Pact mock server into the Pact reference libraries

• feat(pact_consumer): Upgrade pact_mock_server to the new 2.0.0 version
• fix(pact_models): ProviderStateGenerator name was not correct
• fix(pact_verifier): Provider state values should be passed to any plugins under a providerState key
• fix(pact_models): Provider state values may be passed in under a "providerState" key
• fix(pact_verifier): Plugin feature was not enabled in the verifier
• fix(plugins): Plugin config needs to have seperate values for HTTP request and response parts

If you are a user of the Pact FFI library, we're hoping to see a new version released very soon with all of the above changes included.

Pact Mock Server​

v2.0.1 was released, which defaults the Pact spec version to the version from the Pact if not overridden.

Pact-Reference - Slack​

Chat with us in: #pact-rust.

Pact-Plugins​

v0.5.0 of the pact-protobuf-plugin was released and contains the following features:

• Supports injecting provider state values into message fields and gRPC metadata

  • An example of usage is provided here

• Better use of package names in resolving messages (Thanks to @stan-is-hate for this mammoth effect and offer thanks to Eric Muller who also took time to review.).

  Compatibility note

  The plugin is backwards compatible (with a caveat for message provider), but not forwards compatible, therefore it is advised that users update usage to the 0.5.0 or greater

v0.5.1 of the pact-protobuf-plugin was released and fixes handling of google.Structs correctly as raised in this issue.

An example of usage is provided here

v0.5.2 of the pact-protobuf-plugin was released and fixes fixes HTTP Protobuf interactions can have a message defined for both the request and response parts.

Ron also added some examples in both JVM and Rust, for tests which use HTTP and gRPC transports in the same test. You can find them here

Pact-Plugins - Slack​

Have you tried out Pact Plugins yet? What's stopping you?

Chat with us in: #pact-plugins.

Pact-Go​

Pact-Go v2.0.7 has been released which updates libpact_ffi to 0.4.22 & adds Windows CI coverage.

Pact-Go - Slack​

Chat with us in: #pact-go.

Pact-Python​

Val Kolovos has continued adding features for pact-python, after the blog post announcing async message support in pact-python using the new rust core, he is now working on introducing matchers.

If you want to get involved, don't forget, we have a Pact Compatibility suite which is a set of BDD style tests to check compatibility between Pact implementations. There are full implementations in JVM, and Rust, with Tien over in Pact-PHP using it to guide and validate his Pact Rust core based implementation of Pact-PHP.

Pact-Python - Slack​

Chat to us in: #pact-python.

Pact-PHP​

Artur Neumann dropped in a documentation PR, to help users test multiple interactions, in a single test, thanks!

Pact-PHP - Slack​

Chat to us in: #pact-php.

Pact Ruby​

Want to see V3 & V4 Pact Specification support in Pact-Ruby?

So do we!

There are two ways we can achieve this.

1. Utilise the Pact Rust FFI
2. Implement V3 & V4 spec support in Ruby

The latter option is less preferable, as by reusing the Rust FFI across all of our Pact client libraries, we aim to provide a consistent set of functions and experiences for users. However this may present a paradigm change to existing Ruby users, who had the benefit of using the Pact Core built in Ruby natively, whereas other language users relied on the Pact Ruby Gems being distributed in a standalone mechanism.

We are tracking work across three tickets

• V3 Spec
• V4 Spec
• Pact Rust FFI Integration

Please feel free to have the issues and see if you can help!

Chat to us in: #pact-ruby.

Pact-Compatibility-Suite​

A Set of BDD style tests to check compatibility between Pact implementations has been created in the pact-compatibility-suite

Current examples

• pact-rust
• pact-jvm
• pact-php
• pact-python
• pact-ruby-ffi

In order to validate pact-go, pact-js & pact-ruby and it's adherence to the pact-specification, it would be good to begin to implement the following tickets.

• Verify Pact-Go against pact-compatibility-suite
• Verify Pact-JS against pact-compatibility-suite
• Verify Pact-Ruby against pact-compatibility-suite

Anyone is welcome to start implementing these, we are beginning to see contributors to pact-pythons v3/v4 implementation, so why not join in?

Community Events​

Are you talking about Pact or contract-testing this year at an event? Why not let us know and get yourself featured!

Mark Bradley - GopherConUK 2024 (Talk)​

Mark Bradley spoke at GopherConUK 2024 about "Using Pact to deploy Microservice with confidence". Thanks Mark, we will be reaching out to send you some swag!

Augusto Colombelli - Contract Tests — APIs Guided by Consumers (Blog)​

Augusto Colombelli dropped in a PR to list his latest blog Contract Tests — APIs Guided by Consumers, which you can read over on Medium here.

Bas Djistrka - Practical contract testing with Pact (Course)​

Bas Djistraka from OnTestAutomation has just published details on his newest course, Practical contract testing with Pact. I'll let Bas describe it in his own words.

Contract testing is an approach that addresses the challenges of large-scale integration and E2E testing in distributed systems. It is not a new technique, in fact, it has been around for several years now, but unfortunately there aren't many good introductions, examples and use cases that clearly show the added value of contract testing, and how it can help speed up integration testing.

This course is designed to change that. Through hours of videos, quizzes and hands-on programming exercises, you will learn everything you need to know about contract testing, Pact and the tools in the Pact ecosystem.

You can take a look at the https://ontestautomation.teachable.com/p/practical-contract-testing-with-pact to find out more and sign up.

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 5.8K other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

👋 Hey all, 2024 is racing ahead ⏳, we are now 212 days into the year 😲, as I write this July Pact Post. As usual, I'll be keeping you up to date with all the latest happenings across the Pact Ecosystem.

Pact OSS Updates​

General Updates​

Pact RFC Process​

As you may be aware, there are multiple places where one can get help or request changes to the Pact ecosystem, either across the whole ecosystem, or for an individual repositories. Canny, our public roadmap, GitHub project boards on individual repositories, Slack to name a few.

Some of Pact's maintainers also work together, and as such conversations, discussions and agreements can be made but not consistently communicated, leaving users, for example who don't frequent Slack, or one of our maintainer sessions, to feel excluded from conversations.

As such we've decided to deprecate our Canny roadmap and have migrated 95% of the issues to GitHub, in our new Roadmap repo, to keep issues close to where the code is.

To try and counter some of the concerns around the decision-making process, we felt a RFC (Request for comments) process would be beneficial to allow for a record of proposed changes and decisions, and provide a central place to users, contributors and maintainers to go.

You can view the first pass at what the RFC process may look like in this proposed PR.

We would love users to participate and help shape the future of Pact you want to see.

Specific language updates​

Pact-Reference​

Pact FFI​

Another month, another release for libpact_ffi, this time 0.4.22

It includes some QoL fixes, including correcting pact-plugin shutdown behaviour on Windows, and users being unable to find pacts #67, when using a Pact Broker URL which is hosted on a sub path #420

For a full list, check out the release notes.

Pact Mock Server v2.0 is here \o/​

We mentioned in April, that Ron was redesigning Pact Mock Server, as the existing mock server implementation was written in 2017-2019, and contained some esoteric TLS code that was more complex to upgrade to Hyper 1.0 than to rewrite it using newer Hyper 1.0 constructs.

Upgrading to Hyper 1.0 also brought us the following benefits:

• Supports both HTTP 1 and 2 with the same server implementation
• Supports protocol upgrades (leading to supporting things like Web Sockets)
• Middleware support
• No more need for the custom TLS code

Check out the release log to find out what went into the rewrite, and watch out for the updated mock server making it's way through the Pact ecosystem shortly.

Pact-Reference - Slack​

Chat with us in: #pact-rust.

Pact-Plugins​

It's been nearly 2 years since we introduce the Pact Plugin framework to the world.

We've seen 2 plugins created by Pact maintainers (pact-protobuf-plugin, pact-csv-plugin), 2 created by non-maintainers (pact-avro-plugin, in-house json-rpc plugin) and provided a course to guide you on how to build your own plugin (pact-matt-plugin).

We know there are some rough edges, and we have been mulling over what the future of Pact-Plugins could look like. We want to start gathering feedback from users, maintainers and plugin authors, even if you tried it out and got stuck. We will see an RFC (request for comments) ticket being raised in the Roadmap soon and we would like to hold some group sessions to discuss, where participants will get to earn some swag for their time, as well as the satisfaction of being able to shape Pact Plugins destiny, whatever that may be!

Pact-Plugins - Slack​

Have you tried out Pact Plugins yet? What's stopping you?

Chat with us in: #pact-plugins.

Pact-Go​

Pact-Go v2.0.6 has been released which updates libpact_ffi to 0.4.21, go deps, and you'll find an updated Dockerfile which is tested in CI, along with newly added MacOS CI runners (both x86_64 & arm64). Windows CI will be added soon, the pact-plugin shutdown fix came out of issues in executing plugins in this PR. Oh and you might have found that if you are using plugins in pact-go, that they aren't shutting down cleanly, fixed that for you.

I've also been trying to track down a pesky intermittent bug on MacOS/Linux systems whilst using plugins. Some workarounds were applied directly to pact-go in the above release, however I believe the proper solution is in the pact-plugin driver. I've added a pull request which I hope to get merged soon, and pulled in pact-go.

Pact-Go - Slack​

Chat with us in: #pact-go.

Pact-JS​

Pact-JS-Core v15.1.1 has been released which updates libpact_ffi to 0.4.21.

Pact-JS v13.1.1 has been released which fixes #1229 - MatchersV3.reify doesn't extract payload from MatchersV3.nullValue()

Pact-JS-CLI is doing well, we are seeing lots of users switching over going by the ~23.5k downloads since we released it last month. I've put in a PR for review, which aims to leverage npm's optional dependencies, to support packaging and releasing of os/arch specific npm packages, which are consumed in the main project. This has the benefits of ensuring that only the required binaries for the platform you are running on, are downloaded.

Pact-JS - Slack​

Chat with us in: #pact-js.

Pact-Python​

Val Kolovos has continued adding features for pact-python.

Check out the PR here: Feat/async message provider and keep a lookout on the pact-python blog for a dedicated post soon

Thanks Val 💛!

If you want to get involved, don't forget, we have a Pact Compatibility suite which is a set of BDD style tests to check compatibility between Pact implementations. There are full implementations in JVM, and Rust, with Tien over in Pact-PHP using it to guide and validate his Pact Rust core based implementation of Pact-PHP.

Pact-Python - Slack​

Chat to us in: #pact-python.

Pact-PHP​

Tien has been enjoying the summer, and a well deserved break after the epic work bringing the pact rust core to pact-php, so put down that 🍸 and give it a try!

Anyone can start testing pact-php with pact_ffi code by updating their composer.json

"pact-foundation/pact-php": "10.0.0-beta2"

This brings a raft of features to the Pact-PHP ecosystem including V4 Pact Specification support, access to the Pact Plugin ecosystem and huge speed benefits over the 9.x Ruby based release.

You can see a full range of examples here

Pact-PHP - Slack​

Chat to us in: #pact-php.

Pact-Net​

Want to see Pact Plugin support in .NET?

There is an open RFC where you can add your input, and possibly contribute to bringing the capabilities to pact-net.

To help nudge this along, I've created a suite of .NET examples exercising many of the known pact plugins in the ecosystem, along with the raw pact_ffi calls required to utilise them.

You can check it out here - https://github.com/YOU54F/pact-dotnet-ffi-plugins

In order to get this into Pact-Net, one would need to propose some API designs in the RFC, and then can leverage the examples I've created (probably adding your own .NET developer flair to them), to leverage Pact-Nets idiomatic API design, and use plugins in their current V1 form.

We appreciate there are some rough edges, and will be opening the floor to a discussions around the existing framework to ascertain where improvements need to be made or if a V2 design is warranted and what that may look like.

However we shouldn't let the future dictate what we can achieve now, so forth and plug pact-net into the pact-plugin ecosystem!

Pact-Net - Slack​

Chat with us in: #pact-net.

Community Events​

Are you talking about Pact or contract-testing this year at an event? Why not let us know and get yourself featured!

Holistic Testing with Microservices - Lewis Prescott​

Agile testing evangelists Lisa Crispin & Janet Gregory had Lewis Prescott on talk about how to use holistic testing with microservices and contract testing. Don't miss it over on YouTube here

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 5.7K other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

👋 It's June, we've just passed the Summer Solstice, and some of you may be engrossed in footie-fever supporting your favourite team at the Euros ⚽. Good luck!

In this month's update, we will showcase what has been happening across the Pact OSS Ecosystem, letting you know how we got on at GitHub's Merge festival in Berlin, and sharing some of the latest community events coming up this year.

Pact OSS Updates​

General Updates​

Specific language updates​

Pact-Reference​

The Pact Rust core saw a good set of enhancements and fixes this month, with the latest release of pact_ffi 0.4.21.

This is mostly being driven by an increase of usage of the FFI interface, across client libraries which is resulting in issues being raised and fixed. Some of the key highlights include:

• Content Type detection was improved for repeatable behaviour cross-platform. PR here
• Merging pacts would result in duplicate interactions, this has now been fixed. PR here
• Work on improving the message related FFI interface.
  • Discussion here, get involved.
    • feat(ffi): add async message iterator
    • feat: add with_generators
    • feat: add generate_contents methods
    • feat(ffi): add with_metadata

Check out the release notes here

If you've spotted something, once you've raised an issue, sometimes the best way to try and sort it, is yourself. We are happy to guide through the process, so don't be shy, get involved!

Pact-Reference - Slack​

Chat with us in: #pact-rust.

Pact-Plugins​

Ali Ustek helped with some maintenance work and updated the pact-plugin JVM driver to Gradle 8. It was a decent bit of work and it's much appreciated as it saves the core maintainers time to focus on other areas.

Pact-Plugins - Slack​

Have you tried out Pact Plugins yet? What's stopping you?

Chat with us in: #pact-plugins.

Pact-Go​

Back in April, GoLang recently introduced v1.22.x which has affected some of our users, and was raised: Runtime error occurs with golang 1.22.x.

It transpires the error was actually at our end, and was solved by the issues original poster fix: use the same signature for the same function (#402).

There was some impressive debugging done by the GoLang team which makes for an interesting read. Check it out here.

I'm going to use some of that new found knowledge to help me with my own debugging in the future.

Pact-Go has also been updated to v0.4.21 of the pact_ffi library, bringing smaller binaries, improved content-type detection, and the next pact-go release will be the first to offer native alpine support. Subscribe or star the repo for notifications, otherwise I'll update the post to let you know when it's released.

How are you finding Pact-Go? Let us know in the Slack channel.

Pact-Go - Slack​

Chat with us in: #pact-go.

Pact-JS​

Few bits of big news for Pact-JS this month:

• Pact CLI tools (ruby based) have now been moved from @pact-foundation/pact-core to @pact-foundation/pact-cli. This is to make it easier for users to find the CLI tools, and to make it easier to maintain the codebase. You can find the new CLI tools here and read the migration guide here.
  • This dropped the package size from 353 MB to 164 MB
• Alpine Support is here! Pact-JS now supports Alpine Linux, which is a lightweight Linux distribution that is commonly used in containerized environments. This is a big win for users who are using Alpine Linux in their environments previously having to port applications to a glibc (debian etc) based distro.
  • Pact-JS-Core from v15.1.0
  • Pact-Core from from v13.1.0
• Package sizes are now smaller, the pact rust core binaries have been made smaller, so despite adding 2 new platform/arch combos, the package size has further been reduced to 116 MB.
• Content-Type detection is improved via a fix in the pact rust core.
  • Related pact-js-core issue here

Pact-JS - Slack​

Chat with us in: #pact-js.

Pact-Python​

We spoke last month where Val Kolovos assigned himself to one of the tasks: Add support and example for a message consumer test using Rust engine and we wished him luck!

We are pleased to say that we now have a V3 and V4 async message consumer test example in the Pact-Python codebase. This is a great step forward for the Pact-Python ecosystem, and we are excited to see how this will help users in the future.

Check out the PR here: Feat/async message consumer

Thanks Val 💛!

If you want to get involved, don't forget, we have a Pact Compatibility suite which is a set of BDD style tests to check compatibility between Pact implementations. There are full implementations in JVM, and Rust, with Tien over in Pact-PHP using it to guide and validate his Pact Rust core based implementation of Pact-PHP.

Pact-Python - Slack​

Chat to us in: #pact-python.

Pact-PHP​

The v10 Beta2 release is here, which includes the new pact_ffi 0.4.21 release and all the fixes that came along with it.

Check out the release notes here

Anyone can start testing pact-php with pact_ffi code by updating their composer.json

"pact-foundation/pact-php": "10.0.0-beta2"

This brings a raft of features to the Pact-PHP ecosystem including V4 Pact Specification support, access to the Pact Plugin ecosystem and huge speed benefits over the 9.x Ruby based release.

You can see a full range of examples here

Pact-PHP - Slack​

Chat to us in: #pact-php.

Community Events​

Are you talking about Pact or contract-testing this year at an event? Why not let us know and get yourself featured!

GitHub Merge Festival - Berlin​

We had a great time at GitHub's Merge festival in Berlin), where we had the opportunity to meet some of you in person. It was great to see the community come together and share their experiences with Pact. We also had the opportunity to listen to some of the GitHub team and other event members, and discuss how we can continue to work together to make the developer experience even better.

If you are close to Berlin but didn't get to this event, don't miss the WeAreDevelopers World Congress on 17-19 July 2024. We won't be there unfortunately, but it's a great event to attend if you are in the area.

It got pretty busy :)

Brighton Java User Group​

Bas Dijkstra is continuing his contract testing tour, this time in Brighton on the 25th July, with the topic 'Solving the integration testing puzzle with contract testing'. If you are in the area, make sure to check it out.

GopherConUK 2024​

Mark Bradley will be speaking at GopherConUK 2024, 14th-16th of August. He his topic will be "Using Pact to deploy Microservice with confidence". If you are attending, make sure to check out his talk.

You can also check out some of his previous material on the topic of Pact, on his blog site here: https://mark-bradley.net/tag/pact/.

Community Videos​

Made some cool video content showcasing Pact? Let us know to get featured!

What is contract testing?​

Check out Daniel Knott providing an introduction to contract testing, along with further reading to help aid your journey. Check it out on YouTube here. He covers many different testing topics, so this along with it others are certainly worthy of your time.

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 5.5k other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

👋 It's May, and time is flying as we move into the 2nd half of the year. I'll be bringing you the usual updates from the world of Pact in the last month.

Pact OSS Updates​

General Updates​

• Alpine is now supported in the pact-reference core
• The builds are static, and therefore the single binary works across musl or glibc based distros (excluding ffi)
• pact_ffi library comes in both static *.a & shared *.so variants for musl, depending on the consuming client libraries requirements for ffi interop

Specific language updates​

PHP​

Pact-PHP V10 Beta Release​

The v10 Beta release has landed due to an epic amount of work from Tien Vo Xuan and Lewis Cowles

Check out the release notes here

Anyone can start testing pact-php with pact_ffi code by updating their composer.json

"pact-foundation/pact-php": "10.0.0-beta1"

This bring a raft of features to the Pact-PHP ecosystem including V4 Pact Specification support, access to the Pact Plugin ecosystem and huge speed benefits over the 9.x Ruby based release.

You can see a full range of examples here

Pact-PHP Alpine Support​

You'll also be pleased to know, that the 10.0.0-beta1 is the first of the client libraries to support Alpine! 🎉

Pact-PHP - Slack​

Chat to us in: #pact-php.

Pact-Reference​

Pact-Reference - Pact FFI​

0.4.20 of libpact_ffi was released

This release allows optional query parameter values, as well as fixing a pesky warning that was cluttering users consoles. It also pins our shared library to glibc 2.23 for linux gnu targets (non-musl). This allows users of RHEL8 and other older supported distros to still utilise the pact_ffi library, as well as those on later distributions.

• feat: optional query parameter values
• fix: downgrade JSON parsing from warn to debug in from_integration_json_v2
• chore: build linux x86_64 ffi against glibc 2.23

Pact-Reference - Pact Mock Server​

Ron has started a redesign/rewrite for a V2 version of the Pact Reference Mock Server, and would find it easier to support multiple versions with branches it the crate is not in a mono-repo (pact-reference).

Therefore the action was taken to move it from its home in pact-reference to its own repository

You can find it here https://github.com/pact-foundation/pact-core-mock-server

• The pact_mock_server code resides here
• The pact_mock_server_cli code resides here

Pact-Reference - Pact Stub Server​

A couple of features dropped to

• Reduce binary size of all executables
• Build Linux executables statically built with musl
• Add Windows Arm64 Support
• Publish images to Github Container Registry

Pact-Reference - Pact Stub Server - Docker​

Pact-Reference - Pact Stub Server - Docker - Supported Platforms​

Multi-platform images are available, and can be used cross-platform by setting the platform flag.

• --platform=linux/amd64
• --platform=linux/arm64

  docker run --platform=linux/arm64 -t -p 8080:8080 -v "$(pwd)/pacts/:/app/pacts" pactfoundation/pact-stub-server -p 8080 -d pacts

Pact-Reference - Pact Stub Server - Docker - Supported Registries​

Docker images are published to multiple registries

• DockerHub Image
• GitHub Container Image

Pact-Reference - Pact Stub Server - Supported Platforms​

Note: From v0.6.0, Linux executables are statically built with musl and as designed to work against glibc (eg, Debian) and musl (eg, Alpine) based distos.

Pact-Reference - Slack​

Chat with us in: #pact-rust.

Pact-Plugins​

A couple of features dropped to

• Reduce binary size of all executables
• Build Linux executables statically built with musl
• Add Windows Arm64 Support

Pact-Plugin-CLI - Supported Platforms​

Note: From v0.1.2, Linux executables are statically built with musl and as designed to work against glibc (eg, Debian) and musl (eg, Alpine) based distos.

Pact-CSV-Plugin - Supported Platforms​

Note: From v0.0.6, Linux executables are statically built with musl and as designed to work against glibc (eg, Debian) and musl (eg, Alpine) based distos.

Pact-Protobuf-Plugin​

A couple of features dropped to

• Reduce binary size of all executables
• Build Linux executables statically built with musl
• Add Windows Arm64 Support

And we saw a community fix from new contributor Eric Muller in this PR

• fix: respect package namespaces when resolving message descriptors

Pact-Protobuf-Plugin - Supported Platforms​

Note: From v0.3.15, All Linux executables are statically built with musl and are designed to work against glibc (eg, Debian) and musl (eg, Alpine) based distos.

Pact-Protobuf-Plugin - Slack​

Have you tried out Pact Plugins yet? What's stopping you?

Chat with us in: #pact-plugins.

Golang​

Pact-go:

v2.0.5 is out which includes Janez Justin's change we spoke about last month and updates several dependencies in the project.

Chat with us in: #pact-go.

Pact-JS​

Pact JS Core saw a few new fixes, which thanks to npm's package resolution and our use of a caret in our dependency of @pact-foundation/pact-core in @pact-foundation/pact, means you will pull in the latest fixes, without a new release of @pact-foundation/pact

• fix: update standalone to 2.4.4
  • This updates to Ruby 3.3.1
• fix: update pact-ffi to 0.4.20
  • This resolves pact-core@14.3.4: Failed to load native module in Linux-x64 platform (redhat ubi8 minimal)
• fix: node doesn't run .bat files on windows
  • This may have caused this issue: https://github.com/pact-foundation/pact-js-core/issues/506. Are you affected? Let us know in the issue, or drop us a PR to resolve.

Pact-JS - Alpine support​

A pull request has gone in to bring alpine/musl support to pact-js-core and pact-js. It will close this open RFC.

Please feel free to take a look, drop a review, or a comment to say that this is a feature you would like!

If you'd rather wait until its released, please try it out in your projects and let us know how you get on.

Pact-JS - Slack​

Chat with us in: #pact-js.

Python​

Pact-Python:

Pact Pythons core maintainer has been enjoying a well-earned holiday for the last month, and in true open-source style, 2 new contributors arrived, wanting to get involved in extending the Pact Rust FFI support in Pact-Python.

Shout outs go to David Rettie & Val Kolovos, who are getting involved. It all started with a question

hello! I'm interested in putting some time into helping out with the pact V3/ffi tasks. I've been familiarising myself with the codebase and work done so far, I'm wondering if any other contributors or maintainers would like to have a call to help me get on the right track ?

Val dove in head first and naturally came up against a few blockers, questions are always welcome, especially as the help often paves the way for others.

I'm currently working to implement the v3 message_consumer.feature test. I've made pretty good progress, but I just got stuck on generators. I haven't been able to find anything in any of the other languages, so I was hoping someone here might be able to point me in the right direction.

Val has currently assigned himself to one of the tasks: Add support and example for a message consumer test using Rust engine and we wish him luck!

If you want to get involved, don't forget, we have a Pact Compatibility suite which is a set of BDD style tests to check compatibility between Pact implementations. There are full implementations in JVM, and Rust, with Tien over in Pact-PHP using it to guide and validate his Pact Rust core based implementation of Pact-PHP.

Chat to us in: #pact-python.

Community Events​

Praveen Erode Mohanasundaram - Contract Testing: The Key to Unlocking E2E Testing Bottlenecks in CI/CD pipelines​

Long time Pact advocate and community contributor Praveen Erode Mohanasundaram spoke at Devoxx UK about Contract Testing: The Key to Unlocking E2E Testing Bottlenecks in CI/CD pipelines.

I'll let Praveen give an overview of his talk

As organisations embrace microservices architecture to achieve rapid, independent deployments, they often encounter obstacles that impede these benefits. A common challenge is an overreliance on traditional end-to-end testing strategies, which, while providing confidence, can slow deployment, create dependencies, and limit team autonomy.

Drawing from the transformative journey at Discover Financial Services, where we navigated the challenges of modernising systems into a microservices architecture, this presentation will delve into the hurdles encountered, the pivotal role of contract testing in overcoming these challenges, various contract testing strategies and open source tools, and our evolutionary path towards embracing contract testing. Join me to discover how this approach became the catalyst for removing bottlenecks in our CI/CD pipeline, unlocking the true potential of microservices for unparalleled agility and success

Interested? Well lucky for you, you can catch the video on YouTube 📺

TestGuild - Getting the Most Out of Open Source with Yousaf Nabi​

I recently spoke with Joe Colantonio about all things open-source, you can check it out via multiple mediums via the links on the TestGuild site, whether you prefer watching a video or listening to a podcast, Joe has got you covered.

Pact Showcasing at the GitHub Open Source Fair @ The Merge - Berlin​

THE MERGE is a developer experience conference brought to you by GitButler, a dev tool company founded by the co-founder of GitHub. They are bringing together technical founders and execs from companies such as GitHub, Sentry, Heroku, and Tauri to discuss all things developer tools and the communities they built around them.

There will also be an Open Source Fair where 24 selected projects will get the chance to showcase!

We are proud to announce that Pact was selected, so we will be there spreading the Pact love far and wide.

If your in Berlin, June 13th-14th, why not come and talk to us!

Book updates - Contract Testing in Action​

Another 4 chapters have just dropped for the book Contract Testing in Action on Manning, written by Marie Cruz and Lewis Prescott.

If you are new to Pact, be sure to check it out! 🎉

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 5.5k other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

👋 Hello and welcome to the April update from the world of Pact. We've got a varied selection as always, but my personal favorite is all about a 📖.

Read on to find out, as I'm not going to spoil the surprise. 🙊

Pact OSS Updates​

General Updates​

GitHub Actions recently switched macos-latest runners to macos-14 which is MacOS Sonoma running on an arm64 (apple silicon) processor over its predecessor x86_64 (intel).

Hopefully that hasn't given you much grief, but it certainly has had an impact on some of our workflows which we've needed to rectify.

macos-11 will be deprecated some time in June, and users should prepare for a time where only arm64 macos machines are available on GitHub actions, and ensure use of Rosetta for any x86_64 invocations.

Specific language updates​

PHP​

Pact-PHP:

Tien Vo has been continuing the trend with many more pull requests against the Pact-PHP project, preparing for the launch of Pact-PHP v10.x

Pact-PHP v10.x is now mainlined on the master branch, and Pact-PHP v9.x has moved to the release/9.x branch.

We've just synced the latest docs from the repo, to the website, so you can find Pact-PHP's new docs here

You can find the full list of April's merged pull-requests here. I've elected not to list them, as the current number is 37! 🚀

Why not help us make it 38!

Chat to us in: #pact-php.

Pact-Reference​

Pact-Reference:

We've seen a raft of features and fixes land this month in Pact-Reference. Mainly driven by Tien Vo (Pact-PHP) & Josh Ellis (Pact-Python) during their work in implementing the pact-ffi in their respective languages, and trying to implement the full Pact compatibility suite. We also as usual have users working with the pact-reference project raising issues and proposing fixes via PR's. We are grateful for all the feedback, and contributions to the project.

Features & Fixes:

• feat: Optional Query Parameter Values
• feat: Match headers with ArrayContains and EachValue matchers
• feat: Match query with ArrayContains and EachValue matchers
• feat: composing matching rules
• fix: Parse user-agent as single value headers

Chat with us in: #pact-rust.

Pact-Plugins​

Pact-Plugins:

Pact Plugin Driver​

• Ron found an issue in the Rust plugin driver, which was causing slow-down issues on Windows machines. The upshot of his findings, is that plugin based tests on Windows should run quicker. You can check out the commit here. If you are using the Pact-FFI, I think you'll need to wait for a release beyond libpact_ffi-v0.4.19 to be cable to consume these.

Pact-Protobuf-Plugin​

• A range of fixes were released in v0.3.14 of the pact-protobuf-plugin off the back of this raised issue. For the full list of changes, see the changelog

Have you tried out Pact Plugins yet? What's stopping you?

Chat with us in: #pact-plugins.

.NET​

Pact-net:

• Last month we spoke about releasing musl variants on the Pact FFI library. We saw our first community contribution, in consuming these in a Pact client project, in this issue and respective PR. This is exciting to see. I'd love to see linux Aarch64 support for musl and non-musl variants. Fancy dropping in a PR?
• The Road to Pact Plugins.
  • If you are waiting eagerly for access to the Pact Plugin framework within Pact-Net, why not comment on the open RFC where you can register your interest in using it, or potentially contributing to it's implementation.
• The Road to Pact-Net V5.
  • Are you using Pact-Net V5 Beta? Drop us some feedback and let us know how you are getting on. It's really invaluable in helping us decide when to promote from a beta to a release-candidate.

Chat with us in: #pact-net.

Golang​

Pact-go:

GoLang recently introduced v1.22.x which seems to have introduced some defects for the GoLang community, causing segfaults on linux x86_64 machines. This affected some of our users, and was raised here

TL;DR​

Linux x86_64 users

• Using GoLang 1.22.x ?
  • Resolution: disable -race
• Need to use -race?
  • Resolution: downgrade to 1.21.x

Features:

• Janez Justin removed go-getter in this PR in favour of utilising the stdlib's net/http and compress/gzip to download the pact_ffi dependencies for the project. This helped him resolve an indirect vulnnerablity in Pact-Go and has the additional benefit of greatly reducing the size of the dependency tree. Thanks Janez!
• Still stuck on Pact-Go v1.x? You can now publish pacts with the branch property set, thanks to this PR
  • Note: If you are using Pact-Go v2.x, you will utilise the pact-cli tools for publishing pacts, which already supports the branch parameter.

Fixes:

• The main Pact documentation website has been updated to include the new Pact-Go V2 package and documentation. It seems we missed our doc's sync job when promoting V2 from it's beta state. Not to fear though, thanks to a community report for identifying, it has now been rectified and you can find the new documentation here.
  • https://docs.pact.io/implementation_guides/go

Chat with us in: #pact-go.

Pact-JS​

Features:

• feat: support matching numbers, bool in query strings

Fixes:

• fix: broken eachLike V3 documentation
• fix: updated deprecated eachLike V3 description

Chat with us in: #pact-js.

Python​

Pact-Python:

🎺 Pythonista’s rejoice.

We are thrilled to announce the release of Pact Python v2.2, a significant milestone that not only improves upon the existing features but also offers an exclusive preview into the future of contract testing with Python.

Be sure to read about at pact-pythons new doc site, in its inaugural blog post from maintainer Josh Ellis.

Chat to us in: #pact-python.

Community Events​

Solving the integration testing puzzle with contract-based testing​

Bas Dijkstra is an independent test automation consultant and trainer, who has been active in the test automation field for some 16 years now, and has worked on software testing and automation solutions across a wide range of programming languages, frameworks and technology stacks.

He recently delivery a talk about contract testing with Pact.NET, which you can watch here.

I'll hand over to Bas in his own words, to describe what's in store.

Setting up and running integration and end-to-end tests in distributed software systems is hard. Making sure that all components are deployed, with the right version, in the right state, with the right data is a challenging task for many teams.

Contract-based testing is an approach that tries to address this problem and simplify and speed up integration testing for distributed software systems.

In this talk and recorded demo, you'll learn about the basic principles behind contract-based testing, the questions it tries to answer, and the three different approaches to contract-based testing. You will also see contract-based testing in action, using the well-known Pact.Net library for C#. To wrap up the talk, we will also talk about how to adopt contract-based testing in your team and organization, and some of the potential pitfalls that should be addressed along the way.

If you want to get in touch, please use the contact form on his site, or send Bas an email at bas@ontestautomation.com.

Hot new reads​

We've often wondered when a book dedicated to contract testing would appear on the scene. We even had this statement on the books section of our site

We're not aware of any books currently dedicated to contract testing, but here are some that talk about Pact and contract testing as part of a broader microservices development and testing strategy

However good news everybody 🎺

Contract Testing In Action​

We are pleased to announce that Contract testing experts Marie Cruz and Lewis Prescott, have put pen to paper, and have just released the Contract Testing in Action 📕 under the MEAP (Manning Early Access Program).

Contract Testing in Action is a hands-on guide to contract testing for microservices applications and other systems of loosely-coupled components. After learning the basics of contract design and implementation, you’ll dive into constructing your own contract testing framework. You’ll explore the leading contract testing tools, including Pact, PactFlow, and GitHub Actions. Plus, you’ll set up consumer-driven contract testing for REST and GraphQL APIs and learn to integrate contract testing into a CI/CD pipeline. Finally, you’ll delve into provider-driven contract testing, which simplifies adoption by utilizing your existing stack and practices.

What does early access mean for you?

1. You get a book dedicated to Contract Testing, written by industry leading experts.
2. You get the chance to offer direct feedback, into the chapters as they progress. You can join the discussion forum here.
   1. This allows you to stamp your mark on the world of contract testing.
3. If you love the book, we would love the following:
   1. Quotes that could be used in the book
   2. Social Media promotion

How can you get your hands on a copy?

Check out Contract Testing in Actions page on Manning's site.

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 5k other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

Welcome everyone, to that time of year when the 🕒 shifts an hour forward, the 🌞 shines on for a bit longer, which is nice, after a 🥶 and 🌧️ winter. It's March and we are live for another Pact Open Source update.

We've got lots of community contributions this month, and pleased to announce that Pact-PHP v10 is wrapping up for an official release, which will bring that Pact Rust core to more users, bringing speed and reliability benefits over the existing implementation. Huge props go out to Tien Vo 👨🏻‍💻 for the incredible coding marathon, and Lewis Cowles 🕵️ for the code reviews.

Pact OSS Updates​

Specific language updates​

PHP​

Pact-PHP: V10 is nearly here. 🚀 This brings the Pact Rust core to Pact-PHP allowing support up to the Pact V4 specification, which includes http / async & sync message / plugin interaction support, as well as allowing these to all co-exist in a single Pact file.

Here is a bit of a timeline of activities:

• ✅10.0.0-alpha7 release just went live
• ✅ Creation of a release/9.x branch from current master branch for anyone who still want to work on Ruby Standalone code.
• ✅ Merging of ffi branch into master
  • PR
• 🔜 Official release of Pact-PHP v10
  • alpha -> beta -> release

Once again we want to thank Tien and Lewis for their efforts in bringing this across the line. It is a testament to open-source collaboration across the globe, and has been really fun to watch. I really hope you enjoy using the new release. Be sure to drop us feedback like Steve Taylor did in this Github Issue

Not an issue as such, just want to say I love it. (I'm using 10-alpha3) It's so much faster and simpler, and I'm looking forward to using some of the newer Pact specification features. My API tests came across easily without much fuss.

Chat to us in: #pact-php.

Pact-Reference​

Pact-Reference:

• Multi-Arch Docker images.

  • You asked for it, you got it!

    • --platform=linux/amd64

    • --platform=linux/arm64

    • DockerHub Images

      • pact-ref-verifier

        docker pull pactfoundation/pact-ref-verifier:1.1.1
        

      • pact-ref-mock-server

        docker pull pactfoundation/pact-ref-mock-server:1.0.5
        

      • pact-stub-server

        docker pull pactfoundation/pact-stub-server:0.5.3
        

  • Whats left?

    • CI pipeline to automate building/publishing of Docker images
    • Publishing of images to GitHub container registry

• Alpine Support

  • Linux binaries are now built with musl statically linked rather than glibc dynamically.

    • This means any Linux users, regardless of distribution should all be able to use a single architecture specific binary.

  • Releases

    • pact-verifier-cli

      curl -LO https://github.com/pact-foundation/pact-reference/releases/download/pact_verifier_cli-v1.1.1/pact_verifier_cli-linux-$(uname -m).gz
      gunzip pact_verifier_cli-linux-$(uname -m).gz
      mv pact_verifier_cli-linux-$(uname -m) pact_verifier_cli
      ./pact_verifier_cli --help
      

    • pact_mock_server_cli

      curl -LO https://github.com/pact-foundation/pact-reference/releases/download/pact_mock_server_cli-v1.0.5/pact_mock_server_cli-linux-$(uname -m).gz
      gunzip pact_mock_server_cli-linux-$(uname -m).gz
      mv pact_mock_server_cli-linux-$(uname -m) pact_mock_server_cli
      ./pact_mock_server_cli --help
      

  • Whats left?

    • The following projects require updating to build single linux binaries built with musl
      • pact-stub-server
      • pact-plugin-cli
      • pact-protobuf-plugin
      • pact-csv-plugin

  • Pact FFI Alpine specific static and shared libraries

    • These are now published, and require consumption in client libraries. Contributions are welcome, otherwise you'll hopefully see these rolling out throughout the year.

Chat with us in: #pact-rust.

Node JS​

Pact-JS​

Pact-JS Features​

Corporate proxy support was delivered by Zac Poe in this pull request

• feat(corporate proxy #1188)

In Zac's words

Add native support of HTTPS_PROXY and HTTP_PROXY for verifier for #1188

This change adds two pieces of behavior:

• The verifier's 2 step parse body behavior now uses a proxy request buffer (instead of the 'proxyReq' rewrite behavior) to ensure the request stream is accessible for intermediary agent behavior
• The verifier natively supports HTTP_PROXY/HTTPS_PROXY config and assigns a proxy http Agent where those values are present

This results in out-of-the-box support for corporate proxies in the js verifier

Thanks Zac 🙌

Pact-JS Fixes​

Dany Marques went down the NPM rabbit hole, to investigate the root cause of a very interesting bug, affecting NPM registry proxies, and npm script-jacking!

Some long nights with his detective hat on, saw Dany find a suitable workaround as an interim for the Pact-JS project, as well as upstream fixes to the npm project itself. We cannot thank you enough for your herculean efforts.

• PR
• Longest Slack thread ever xD - 213 replies!
• Read more about manifest confusion in this medium blog (You may want to use incognito mode, if you don't have an account)

Matt Fellows fixed an issue where matching rules are not supported in messages: pact-foundation/pact-js#1183.

If you've been stuck on either of these issues, be sure to give it a re-test!

• Use matchers when verifying metadata
• (TypeScript) Cannot use V3 matchers within MessagePact. Types are incompatible.

Chat with us in: #pact-js.

React/Cypress users​

Gearóid Ó Treasaig upgraded one of our example repos which contains our vanilla React "Product" API consumer used across all the JS HTTP based examples, and additionally includes Cypress and Pact-Cypress-Adapter.

Gearóid utilized graphite.dev to stage his pull-requests in distinct commits. The PR for good reading if you are preparing for upgrading some major dependencies in your JavaScript project, and want an example to follow. Thank you, we really appreciate it.

If you want to get involved, why not pull down the example and try it out, or apply upgrades to one of our many example repos. We would greatly appreciate it, and it is a neat way to start contributing to open source, if you haven't managed to already, but want to start somewhere!

Pact Broker​

Pact-Broker: Multi-Platform support + GitHub container registry support.

Multi-platform images are available

• --platform=linux/amd64

• --platform=linux/arm/v7

• --platform=linux/arm64

• DockerHub Image

  docker pull pactfoundation/pact-broker:latest
  

• GitHub Container Registry Image

  docker pull ghcr.io/pact-foundation/pact-broker:latest
  
  • Note: The Org name needs to match our GitHub org, so note the additional hyphen - between pact-foundation

Pact Broker on AWS Fargate with CDK​

The beauty of the Pact Broker nature as a Docker image, means that it can be deployed in a multitude of different ways, and the architecture considerations are the end users to determine, implement and manage.

There are projects which seek to offer experiences with Terraform & Helm in order to provide some out-the-box experiences for regular deployment platforms.

Most of these have come from community contributions, either publicly displayed on GitHub, or shared back into the Pact-Foundation, such as pact-broker-chart.

I'm pleased to announce that we've had a community contribution by learnautomatedtesting of a PactStack, an open source tool utilizing gitlab AWS CDK to publish and deploy a serverless framework of the pactbroker and postgres database.

PactStack is a serverless solution for running a Pact broker alongside a PostgreSQL database entirely on AWS Fargate, leveraging the AWS Cloud Development Kit (CDK) for infrastructure as code. This solution is designed to facilitate contract testing between microservices by providing a centralized broker for storing and retrieving Pact contracts. The stack includes an ECS cluster, Fargate services for the Pact broker and PostgreSQL database, a CloudWatch Log Group for logs, and an S3 bucket for storing Pacts.

You can check out the repository here and see it in action against a full worked example

We've not had the chance to test this out yet, but if it appeals to you, please feel free to try it out and let the author know if you have any issues.

Chat to us in: #pact-broker.

Pact Ruby CLI​

Pact-Ruby-CLI: Multi-Platform support + GitHub container registry support.

Multi-platform images are available

• --platform=linux/amd64

• --platform=linux/arm/v7

• --platform=linux/arm64

• DockerHub Image

  docker pull pactfoundation/pact-cli:latest
  

• GitHub Container Registry Image

  docker pull ghcr.io/pact-foundation/pact-cli:latest
  
  • Note: The Org name needs to match our GitHub org, so note the additional hyphen - between pact-foundation

Chat to us in: #pact-ruby.

Pact Docs​

Martin Gallauner is on his road to Pact Nirvana, and has been dropping some edits to the guide as he is working through it.

Thanks Martin, we really appreciate it and know that our end-users will to!

Did you know, that the majority of our website documentation was written by volunteers and it is a collective smattering of shared knowledge. A contract testing wikipedia if you will.

Whilst this is awesome, it can make a new users journey, a little disjointed at times, as they can feel overloaded with information.

We'd love to look at the documentation estate as a whole this year, and redesign our user journeys. If this appeals to you, why not get in touch.

Community Events​

Women Who Go London Feb 2024​

I had the pleasure of traveling down to London and speaking to a load of budding software-engineers at Deliveroo HQ about GoLang via the Women Who Go London group!

How do we test our applications now, what are the benefits and drawbacks of each way of testing and how does integration fit into all of it. Yousaf explains it all and provides examples on how to start contract testing with Go and Pact.

You can check out the slides here

Sanyia Saidova walks us through the journey of how to shape your platform to account for growth in your application - what decisions lay in your path as your userbase grows and how to weight them.

You can check out Sanyia's slides here

Are you in, or near London? Do you love coding? Do you want to build a more diverse and inclusive Go community? Why not join us the WWGL Meetup group and attend an event soon.

Community shout-outs​

Big shout outs go to these contributors for their efforts, big and small.

• Tien Vo for his dedication and determination to complete the pact-php rust core migration, I'm sure it's been a learning journey and you've come out as an even better PHP developer. We hope you can take you learnings and apply in a day job, as many others will be able to apply your code against their projects, providing safety and guarantees for years to come.
• Lewis Cowles for the continual reviews in pact-php and support for Tien Vo.
• Dany Marques for his tenacity in tracking down an obscure bug in the npm ecosystem, and creating upstream fixes, as well as resolving his issue in the interim in the pact-js project.
• Gearóid Ó Treasaig for a series of PR's to improve the quality and health of our examples.
• learnautomatedtesting for the Pact Broker AWS Fargate project and demo.
• Zac Poe for corporate proxy support in Pact-JS

No matter the contributions, your work will make a positive impact to end users, who wish to benefit for Pact's feature-set, no matter the language or the tooling. We love seeing users bring fixes, improvements and new features to the Pact stable. We can help support you, if you aren't sure where to start.

What's stopping you?

Thats a wrap​

Want to carry on the conversation? Sign up here to join our Slack community, where you will be amongst over 5k other users. It's a safe place to ask questions, and a great place to share the awesome work you are doing in the Pact ecosystem.

Whatever you are up to, let us know, and we can look to get you featured in the Pact post.

See you next month folks!

Cheers, Saf

Hello, and welcome to our first Pact Open post of 2024. It seems customary that you get a month's reprieve from me at the start of every year, so I'll start by saying Happy New Year to everyone, and also Happy New Year of the Dragon, to those who celebrated the Chinese New Year recently.

I hope you all had the chance to wind-down, relax and spend time with people you care about, whilst looking back, hopefully with a smile, at all the things you achieved last year. If you helped get involved in Pact, in any way, big or small, we are grateful.

Anyhow, that brings me to February, and I get the pleasure of letting you know what has been happening across the Pact estate over the last 8 weeks!

Pact OSS Updates​

Specific language updates​

Pact-Reference​

Pact-Reference: Lots of changes in the Pact-Reference project, from Ron and others. You'll find Pact FFI 0.4.16 out with a number of QoL improvements from a range of contributors.

• Stanislav Vodetskyi : Support metadata rules for sync message
• Tien Vo
  • feat: Print provider name in 'no pacts found' message to help debugging
  • fix(pact_matching): Allow matching strings using Values matcher
• Josh Ellis : feat(ffi): add with_matching_rules

Chat with us in: #pact-rust.

Pact-Plugins​

Pact-Plugins: The pact-protobuf-plugin has seen an uptick in usage, with several new contributors raising issues and fixes. We appreciate both, especially if the issues come with reproducible snippets as we have been seeing. Keep it up.

• Stanislav Vodetskyi : Support metadata rules for sync message
• Rohit G Krishnan : Fix merging between plugin config and manifest values.

Fixes by Ron:

• fix: accept empty maps where there is a eachKey or eachValue matcher
• fix: when checking for unexpected fields, ignore fields with default values
• fix: Missing fields may have been dropped from the payload if they had a default value
• Issue with matching a list of enums

Have you tried out Pact Plugins yet? What's stopping you?

Chat with us in: #pact-plugins.

.NET​

Pact-net: 5.0.0-beta.2 was released a few days ago which includes the following

• Replaced Newtonsoft with System.Text.Json (see upgrade guide for more info)
• Increased minimum supported .Net Framework version to 4.6.2
• Marked MacOS ARM architecture as fully supported
• Upgraded to FFI 0.4.16
• Upgraded tests to .Net 8 and .Net Frame 4.6.2
• Find unused ports for the messaging server more efficiently

Want to upgrade? Check out the upgrade guide here.

Still on Pact-Net v3.x and want to migrate to the latest stable v4 version? Check out the upgrade guide here.

Whats next? Pact Plugin support! Check out the RFC for more detail, and feel free to add your feedback.

Chat with us in: #pact-net.

Golang​

Pact-go: v2.0.4 has just been released, which bumps the Pact FFI and includes external contributions from Armin Becher and Stanislav Vodetskyi, thanks guys 🚀.

• feat: add native lib path function #376
• fix: allow empty responses in sync messages (#386)
• fix: update pact-ffi to 0.4.16

Armin's change looks to improve the developer experience for GoLang users utilising Windows. Are you one of them?

Chat with us in: #pact-go.

Node JS​

Pact-JS: v12.2.0 has just been released. This introduces the PactV4 interface into GA (it was previously feature-flag enabled). This allows for Pact plugin support to the Pact-JS project. A team effort, led to a vulnerability fix, closing off an outstanding issue, thanks Yukun & Rufei. Matchers can now be applied to response bodies, thanks to this PR

Want to see the plugin framework in action in Pact-JS? Check out our gRPC example here.

Chat with us in: #pact-js.

Python​

Pact-Python: Josh has been continuing to work on the pact-compatability-suite integration in order to verify the Pact-Python integration with the Pact Rust libraries works correctly. You can keep track of the road to V3/V4 and the Rust backed implementation in this tracking issue. We saw a community fix: ensure interactions are not left when exception occur inside with statement from Jakub Stolarkski.

We hope to get a release out shortly, which will bring in an updated pact-ruby-standalone, and support for Python 3.12, and Jakub's fix. Also don't forget to watch the repository, if you want to be first in the loop when the new release lands, and later in the year you can start trialing the pact rust engine in your pact-python projects.

Chat to us in: #pact-python.

PHP​

Pact-PHP: Tien Vo has been on fire over the last 8 weeks, buoyed by Lewis Cowles input at review time. It has been nice to see Lewis dropping in to help lighten the load of Tien as well. It's nice to watch from afar, as I can see them both learning off each other, and goes to show how much collaboration helps as sometimes it can feel like a lonely place when you are just plugging away.

Changes in the FFI branch include:

• Implementing of the V1 Consumer / V1 Provider/ V2 / V3 and V4 pact compatibility suites. If you've not seen the compat suite, it uses Cucumber to describe the Pact features, and Pact-PHP is using the Behat flavour. It is worth taking a look at.

I'd recommend dropping into the FFI branch, and checking out some of the examples where you can see Pact-PHP being used for contract testing gRPC services.

Have you trialed the V10 Beta of Pact-PHP?

Chat to us in: #pact-php.

Pact Broker​

Pact-Broker: Jörgen Andersson is helping keeping the Pact Broker up to date, by updating our base image to Ruby 3.2.3, the Alpine version from 3.17 -> 3.19 and upgrading Supercronic 0.2.29.

Unfortunately moving to Alpine 3.19, broke Sqlite for x86_64 users, in the same way that it had been noted to have been broken in the aarch64 and arm images. We got a couple of reports, one from a fellow maintainer, and another from a user, which provided a cookie trail, which led to a fix, building sqlite3 gem from source, which not only solver the issue in our x86_64 image, and the outstanding aarch64/arm issue as well.

What does this mean for you? We will soon be publishing our multi-manifest images, without a -multi suffix, which means whether you are running on shiny M-Series macbook, a Raspberry PI, or your Intel/AMD gaming rig, you'll be able to pull the latest image, and get a native image that is right for your system.

Chat to us in: #pact-broker.

Pact Ruby Standalone​

Pact-Ruby-Standalone: Our fork of Traveling-Ruby has been updated with a few goodies.

What does this mean for users of the Pact Ruby Standalone project?

• The ruby runtime is updated to Ruby 3.2.3
• The bundled version of OpenSSL is now bumped to 3.2.0
• The dependency on bash is gone! Yep, you heard that right, you can get away with sh only which means no more bash required in your Alpine images.

Pact Workshops​

The following workshops have been updated to use the latest versions of the Pact client libraries:

• Pact-workshop-go
• pact-workshop-Maven-Springboot-JUnit5
• pact-workshop-jvm-spring

Yo dawg, I heard you like Alpine​

Unless you've been living under a rock, you've probably heard about Alpine. If not, it is a variant of Linux, which many teams choose to run their builds on due to its tiny footprint, and smaller security surface area. One of the significant areas of differences to more regular flavour of Linux (Debian/Ubuntu/Fedora etc), are it's choice of standard library. With Alpine choosing musl whilst others prefer glibc. This poses challenges for distributors of packages used within the Linux ecosystem.

So lets take a look at our options.

1. We provide a single distribution, linked to glibc:
   1. Users need to be aware that the distribution is linked to glibc.
   2. Alpine users are required to perform workarounds.
   3. There will be a performance overhead in calling a program linked to glibc, over musl for Alpine users.
   4. Compatibility is not guaranteed, so further issues may occur, which can become complex to diagnose, especially if not reproducible on a glibc based distro.
   5. Maintainers need to ideally update their code to detect the presence of musl, to inform users of compatability issues. In many cases, glibc programs won't run without the Alpine workarounds, and therefore there is no ability in code to provide useful messages to users, so the onus is on them reading the documentation.
2. We provide two distributions, one linked to glibc, one linked to musl:
   1. Users need to be aware of which std library they use, glibc or musl.
   2. Maintainers need to ideally update their code to detect the presence of musl, so they can provide the correct musl package to users. This can be challenging.
   3. Alpine traditionally prefers creating static builds, which can cause the inability of client languages to link to the shared C libraries.

Rust Core​

Alpine support has not been made available to the pact-reference project, often referred to the Pact Core, with our official guidance on our website:

Alpine is not supported as it requires us to build dynamically linked libraries for each specific version of Alpine and musl. It's possible to make it work, but we make no guarantees and it's likely to break in subtle ways and we would instead recommend adopting Ubuntu or Debian which supports linking to glibc.

I'm not sure how many users have been limited by this, unable to switch from Alpine based containers, and therefore unable to utilise the pact-reference project, and all the V3/V4 Pact Spec goodness, along with the benefits that the Pact Plugin ecosystem providers, however there were enough issues on our repositories to make it a worthwhile wander to investigate. I've documented it in this issue in our pact-foundation/devrel repo.

The pact-core consists of a few elements, which are of use to end consumers, and languages, who are not using Rust.

• Mock Server CLI
• Verifier CLI
• Stub Server CLI
• Pact FFI library
• Pact Plugin Framework
  • Pact Plugin CLI
  • Pact Plugin Drivers
  • Pact Plugins
    • pact-protobuf-plugin
    • pact-csv-plugin

As the project is built with Rust, we can easily add in musl targets, both aarch64 and x86_64 with Cross (we'll talk a little about Cross in our next section).

The CLIs are easy, add in our required targets, build with cross, and out pops a musl based executable.

Shared libraries are a little more awkward. In order to tell Rust to create a shared library, we use the cdylib notation in our Cargo.toml file. This pops out shared libaries, when we build it with the following extensions.

• Linux .so (shared object)
• MacOS .dylib (dynamic library)
• Windows .dll (dynamic linked library)

The extensions here, denote that they are shared libaries. If one was to build them statically, they would return a .a extension, which denotes archive. These files are in order of magnitude larger than their dynamic counterparts, as they self-contain everything needed to run the program, without requiring any external or system libraries.

When we build for Alpine targets, we only get a .a file output. Whilst this is perfect for some of our client languages, some such as PHP, Ruby and .NET to name a few, are unable to read .a files, excluding them from the picture.

It's possible by setting some flags, either as Rust compile time, or by using some gcc commands to take a .a file, and convert it into a shared object file. With this newly created file, we can load it with PHP, Ruby and .NET, in Alpine successfully.

In order to get green test suites, under the Alpine platform, it was necessary to also update parts of the Pact plugin framework to become musl aware, such that if it detects musl, it attempts to download a musl variant of a plugin. If the musl variant doesn't exist, it would be nice if we could attempt to load the glibc variant, which may work with the compatibility workarounds discussed earlier. If we can warn the user, so they can take an proactive actions, even better.

For two of the plugins, protobuf and csv, these are written in rust, so again we can follow our same pattern to enable musl variants. For our sample build your own plugin template, it is written in GoLang, which uses Goreleaser to build the linux variants. There is the added benefit that the application is built linked against musl, but able to be run on machines that link to glibc or musl, meaning there is no need to produce a separate musl named artifact.

The last of the plugins I took a look at was pact-avro-plugin, created by one of our community members Ali Ustek. This particular plugin is written in Java, so required the end user to install at least the JRE, if not the SDK, of Java 17, in order to use it. It also had a requirement on bash, in it's startup script, but the author has since updated this to use a sh based wrapper, meaning end users on Alpine, won't additionally need to install bash. Hooray!

Lower is better​

Whilst we've been talking about glibc/musl, it's usually good to know that they tend to be forwards compatible, such that if you build against an older version of musl or glibc, then your application will work with later versions of each respective library.

If you happen to build your application on the latest version of Alpine (musl) or Debian (glibc), you'll find users of older versions of those distro's will have errors running your application due to missing symbols.

We can resolve that using fixed images, which carefully control the versions of musl/glibc that we link against.

Now rather than creating our own build-box, the cross-rs project allows Rust based projects, to compile (and cross-compile) for multiple targets. Each of these targets, has a corresponding build image, and the team provide a brilliant table of the libc versions in place.

Now you'll note against the main branch, the glibc version is 2.31. This caused issues for several users, often for them indirectly. For example, one might be running an official NodeJS image, for an older version of Node, say version 16. These images are no longer being updated, as Node 16 is EOL, so it's built against an older version of Debian, which runs an older version of glibc, than 2.31. Oh noes!

Whilst our user in our story, was able to unblock themselves by updating to a later node image, which contained a later distribution, we are unknowingly excluding many Linux users from utilising the Pact Framework.

That isn't a place we'd like to position ourselves, as we understand that not only do teams in greenfield applications, who have the freedom to choose their tools and techniques, often pick contract testing, but that teams supporting heritage (legacy) applications, who for many varying reasons, might not have the ability to upgrade their infrastructure to the latest and greatest at the drop of a hat. These teams can benefit too from contract testing and should not be omitted from the frame.

So how do we solve it?

By pinning our version of cross to 0.2.5, our glibc based targets will link to 2.23, as shown in this cross target table

One of our community members Omair Majid posted this table of glibc versions in use across common linux distributions.

Ruby Core​

So what about Ruby? I spoke earlier about our fork of traveling-ruby, which recently underwent some updates. Whilst on my Alpine adventures, I realised that there would now be some disparity between the platforms supported by the Pact Rust core, and the Pact Ruby core. That was an itch, I needed to scratch. Could I bring native musl based support to traveling-ruby? That way not only do we need to tell users, they no longer need bash, due to using sh compliant wrapper scripts, but they no longer would need a compatability layer, if one was running Alpine.

So similar to Cross, the traveling-ruby package uses Docker images to build for Linux. They are referred to as a holy-build-box, and was originally created by the Phusion team, of Passenger fame (and also the creators of traveling-ruby). The box used for building the current linux packages are based on Centos7 which links to glibc 2.17.

So I would need to create an Alpine based holy-build-box and see how far could get. Turns out pretty far and I managed to successfully Alpine/musl based packages for aarch64/x86_64. They were built on an Alpine 3.15 box, and have been tested up to the current 3.19 Alpine release.

Itching to try out the musl based packages? I've published a release from my fork of pact-ruby-standalone, that you can take out for a test drive today.

Who and whose ARMy?​

Multi-Manifest Images​

For the last year, we have been trialing multi-manifest images for the pact-cli and pact-broker docker images, which you have to opt in to use, by appending the tag name with -multi.

We've had a small amount of feedback, mainly all positive, with hopefully the last of the gremlins sorted (Sqlite3 was failing on arm64 images, then x86_64 images, resolved by building from source), so we are beginning to drop the multi suffix.

Pact-CLI has been the first, and also it celebrates it v1.0.0 release. You can find a multi-manifest tag with AMD64/ARM64 and ARM flavours here.

We would also like to publish our images to GitHub container registry in order to alleviate any pain, DockerHub's rate limits may be imposing on teams. The first of a series of PR's across our images is here, and a tracking issue here.

GitHub Actions launches ARM64 MacOS Runners​

We recently introduced ARM64 CI testing capabilities via CirrusCI last year, and rolled it out to several of our repositories, which unlocked cross-platform, cross-architecture testing for our maintainers, however due to licensing changes, CirrusCI began limiting OSS users usage, which mean monthly, builds would fail as we moved over our limits.

This was an inconvenience, but not limiting as we had not removed our existing GitHub Actions workflows, and were infact waiting for GitHub to unlock access to MacOS M1 runners for OSS usage. That time came last month, and we have see it applied to a couple of our repositories already.

If you spot a repo not covered by the new macos-14 runner, why not drop a PR in on the project?

Windows on ARM​

Are you running Windows on ARM? Whether you running it natively, or you are enjoying it via your speedy M-Series Apple processors via Apples Virtualisation framework (Check out UTM for a rather splendid open-source virt tool), I've got some good news for you.

We have started to publish support for Windows on ARM across a few of our projects. I'll borrow our list of Rust tooling before, as it'll highlight some of the gaps that we still need to cover. If you want to see Windows on ARM via your favourite Pact Client library, why not help fill in some of the blanks.

• Mock Server CLI
• Verifier CLI
• Stub Server CLI
• Pact FFI library
• Pact Plugin Framework
  • Pact Plugin CLI
  • Pact Plugin Drivers
  • Pact Plugins
    • pact-protobuf-plugin
    • pact-csv-plugin

So what about Ruby? Not again Saf! Well it turns out Windows on ARM for Ruby, transpired to be a bit more complex, with even x86_64 emulation being broken in some versions. Users would come across this error, which would ultimately be solved for arm64 native builds (still broken in x86_64 emulation mode) via this patchset.

With this in place, it is now possible to compile later versions of Ruby > 3.1 for arm64 via a clangarm64 msys2 environment, and official msys2 packages were released for Ruby 3.1.4.

Traveling-Ruby utilises RubyInstaller2's packages for bundling Ruby and your gems, for distribution, but is awaiting arm64 support, with a request here. One can't utilise the msys2 packages directly, without a couple of tweaks, as RI2 maintains it's own Pacman repository with Ruby builds.

So I had a little dive into RI2, and managed to get it building for ARM64, consumed via traveling-ruby and consumed in pact-ruby-standalone locally.

Community Events​

Eric DeAndrea - How to avoid common pitfalls with modern microservices testing​

Eric DeAndrea spoke this month at the San Francisco Java User Group where he some common battle scars from our experiences in the field. He introduced the testing pyramid and explained why it is important in helping to continuously deploy microservices independently without fear. He also demonstrated, through a test-driven development approach, how the combination of Pact contract testing combined with Quarkus developer joy can help prevent your microservices from breaking in production.

Missed it? Don't worry you can catch the slides here, and you can be sure to hear more from Eric throughout the year. I would recommend following his socials for heads up on his next event.

• GitHub: https://github.com/edeandrea
• Twitter/X: https://twitter.com/edeandrea
• LinkedIn: https://www.linkedin.com/in/edeandrea

WomenWhoGo - London​

If you're based in London, why not link up with the Women Who Go community, who are holding their first in-person event of 2024.

You'll get to hear from Sanyia Saidova from Deliveroo who will be speaking about Growing your application from prototype to production, and I'll be talking about Pact + GoLang - Contract testing for the past, present and the future (and how you can get involved!).

You can check out the meetup event here.

Community shout-outs​

We'd love to give a huge shout out to Stanislav Vodetskyi, who has been going above and beyond to improve the Pact-Go experience, by not only dropping PR's in the Pact-Go project, but rolling up his sleeves, learning Rust on the fly, to provide PR's in the Pact-Reference and Pact-Rust project, to improve the gRPC plugin capabilities, either by bug-fixes or improvements.

It's great to the see the plugin framework being actively used in an organisation, and this adoption helps bring more use cases to the table, and the feedback we receive in terms of Slack, GitHub issues or pull-requests, all go a long way to helping new users embrace Pact Plugins and the DX around it.

If you've spotted an improvement you can make, why not strike up a discussion with the maintainers, or fork the repo and have a play.

Thats a wrap​

Phew, that was a-lot! I didn't even scratch the surface, as this is only a small selection of the repositories across the Pact Foundation. If I missed something you achieved since the start of 2024, be sure to give me a shout so I get you a mention in the post.

If you haven't yet contributed to the Pact project, this is your year. If you are stuck and don't know where to start, why not join us in our Pact Slack community.

Sign up here!

See you next month folks!

Cheers, Saf

Pact Almanac 2023​

Grab your hoverboard, and get prepared for another trip back to the future, with our round up of this years Pactivities in our seasonal Pact Almanac.

We had a raft of code features, patches, fixes and new projects added to the Pact-Foundation over the year. If you haven't read our monthly blog posts, you can read a round-up of the most significant changes from each month in there. Check out the side-bar to the left to view the older posts.

I've mainly focused on video content this time round, where you can find multiple advocates of Pact, spreading the word of not just how to do contract testing, but the why. I hope you'll enjoy them, be sure to like and comment on the videos, whether it's to show your appreciation or you just fancy a debate.

Oh, and if you are the debating type, why not join us in a fireside chat next year?

Anyhow, let see what each month has in store for us.

January​

Kicking off the year, we introduce a blog post from eBay titled API Evolution Is a Challenge. Could Contract Testing Be the Solution? You can read it here

Feb​

Diego Herrera introduced spoke at at EdinburghJS with a talk titled Testing services with Pact. Watch it here

Mar​

Holly Cummins discusses how contract tests combine the lightness of unit tests with the confidence of integration tests, and should be part of your development toolkit. Watch it here

Apr​

Lewis Prescott caught up with Janet Gregory and Lisa Crispin (Authors of the famed Agile Testing book), where they talk about how to use holistic testing with microservices and contract testing. You can watch it here.

May​

In this k6 Office Hours episode, Developer Advocates Marie Cruz (long time Pact friend) and Paul Balogh discuss what contract testing is, if schema testing is the same as contract testing, and how to do schema validation testing using Grafana k6. Check it out here

June​

gRPC and Protobufs are increasing in popularity, however, there are multiple classes of problems that may result in API breaking changes. In this video, we show how you can apply contract testing to gRPC and Protobufs systems using Pact and its Plugin framework. Watch Matt, show a quick demo of it in action here

July​

Dave Farley from Contiunuus Delivery explains why Contract Testing For Microservices IS A MUST, in his video here

For our Polish speaking friends, you can watch Jakub Małyjasiak from Ocado Technology, talk about How Pact is more than just contracts and tests, here from a local meet up Wrocław.

Aug​

DPoint, helped demystify contract testing, in this video here, you can also see it in action with Spring Boot demos for both producers and consumers.

Sept​

Ebay explains Consumer-Driven Contract Testing and how could they use it to improve testing their Microservice APIs with Pact? Watch their video where dive into the theory of Contract Testing, the potential benefits of using it, and some practical examples, here

Oct​

It was Pact's 10th Birthday, and you can find your map to all the resources that came out of our month long celebration in this blog post.

LambdaTest spoke with Bas Djistrka about Solving the Integration Testing Puzzle with Contract Testing, as part of the Voices of Community series. You can watch it here

Nov​

Matt Fellows spoke at Testing Talks Conference in Melbourne, where he provides a comprehensive guide to Pact. Watch it here

Dec​

Angelo kicked off December with a tutorial showcasing interoperability with a PHP backend and JavaScript frontend powered by contract testing, watch it here

See you next year folks​

Thanks for everyone's efforts in using, promoting, and preaching about Pact to everyone you know, now its our time to repay the favour.

If you've done something great, and want to share it, get it listed - the site is open source and you can edit any page, we want to give you a platform to help amplify your voice!

Maybe there is time to get one last video/blog or PR in before crimbo! No, only joking, that’s a wrap for this year's Pact Open Source Almanac, pop your feet up, enjoy your puds and hope to see your name in the book next year.