Which library are you using?

It sounds like you might be using the Ruby service, which is to be deprecated

It exposes a C API which you can probably link against. This is what pact-js and pact-net do.

And pact-go too, I think

I think there’s a guide somewhere

Hm, I can’t find the guide

If an example would help, here’s how pact-js does the verification: https://github.com/pact-foundation/pact-js-core/blob/master/src/verifier/nativeVerifier.ts

The consumer is quite a bit more complex: https://github.com/pact-foundation/pact-js-core/blob/master/src/consumer/index.ts

You’ll also need the ability to create matchers. I don’t believe these are documented, but a good resource for them is pact-js’s matcher code. Let me get you a link

The Rust core will do its own spin up and teardown of the server, so you won’t need to muck about in your test harness

I was involved in some (but not all) of the conversion of pact-js to the Rust core, so I should be able to answer some (but not all) of your questions

(if you have them)

as it uses FFIs , which also supports message pacts

I would start with Pact, though, as it’s ready today

(and has a well established community)

You can follow it here if you’re interested: https://case.contract-testing.io/docs/intro

it works today in JS, but it’s very beta.

Thanks for those tips Tim. @Priyaranjan Mudliar - we are about to kickoff some work around maintainer experience. The key artifacts to emerge from this will be a guide for maintainers, and a BDD suite to use as a basis to test your implementation. In lieu of that, your best bet is to follow a previous implementation (as Tim has suggested) and jump in #C02BXLDJ7JR - we can help. There are a few others on this journey, such as @Tien Vo working on PHP. We’re here to help, it might be a little bumpy given the lack of good maintainer docs. But you’re not the first to do it

i haven’t used it or studied the code so your mileage might vary. we’ve had a fair few over the last couple of weeks asking about the ffi implementation, details on how to use it as a consumer and some reference documentation. the code for me has always been the best source of truth, but appreciate its hard if you don’t know where to look. i’m going to look at setting up an bit of an intro / workshop and tutorial, can i assume that you would be interested? cc: @Adam Cox i think you asked about this re pact-cplus-plus

But before that I would want to go through the JS implementation myself, so that i have context before any such session

@Yousaf Nabi (pactflow.io) Any intro/workshop/tutorial for the ffi implementation would be much appreciated

i’m out at the moment but will put together some initial pointers on a docs page which shows where the reference code ( the pact ffi library lives ), which platforms we aim to support, how we can test it and which implementations currently use it, and where exactly in the code is it done. it will help us identify gaps between implementations, and hopefully feed into the cores design decisions as anything emergent arises

some architecture details on the ffi https://github.com/pact-foundation/pact-reference/blob/master/rust/pact_ffi/ARCHITECTURE.md examples of loading the shared library in various languages https://github.com/YOU54F/hello_ffi the install.md has instructions on how to run on various platforms some raw examples in python and php which call the ffi methods directly https://github.com/pact-foundation/pact-reference/pull/269/files these are normally wrapped in a dsl which is idiomatic for the client language, but ultimately should expose the same feature set across all the client libs. there are some blurred lines as some functionality a ) needs to reside in the client libs to handle talking to the ffi and the user as an intermediary b ) some func is in the client only, and not exposed in the core, which can lead to apparent feature disparity between languages.