feat([PoC]): Contract for sequence of messages.

[Mifrill]

📓 This PR is just a PoC on how to use Pact for a sequence of messages in a single test iteration. However, this approach is opposite to Consumer-driven Contract Testing (CDC), because is test should be as much simple as possible to test only one iteration (request-response) at a time.

When a Consumer expects a few messages in one test iteration current Pact is keeping only the last message in Contract, this modification makes Pact keeps all messages in Contract.

describe TestMessageConsumer do
  let(:expected_payload_1) {
    {
      "first_name": "John",
      "last_name": "Doe"
    }
  }
  let(:expected_payload_2) {
    {
      "hello": "world"
    }
  }
  let(:consumer) { described_class.new }

  describe "Test Message Consumer", pact: :message do
    it "generates contract" do
      test_message_producer
        .given("Class1")
        .is_expected_to_send("created")
        .with_content(expected_payload_1)
      test_message_producer.send_message_string do |content_string|
        expect(consumer.consume_message(content_string)).to eq(expected_payload_1.to_json)
      end

      test_message_producer
        .given("Class2")
        .is_expected_to_send("updated")
        .with_content(expected_payload_2)
      test_message_producer.send_message_string do |content_string|
        expect(consumer.consume_message(content_string)).to eq(expected_payload_2.to_json)
      end
    end
  end
end

Contract:

{
  "consumer": {
    "name": "Test Message Consumer"
  },
  "provider": {
    "name": "Test Message Producer"
  },
  "messages": [
    {
      "description": "created;updated",
      "providerStates": [
        {
          "name": "Class1",
          "params": {
          }
        },
        {
          "name": "Class2",
          "params": {
          }
        }
      ],
      "contents": [
        {
          "first_name": "John",
          "last_name": "Doe"
        },
        {
          "hello": "world"
        }
      ],
      "matchingRules": {
      }
    }
  ],
  "metadata": {
    "pactSpecification": {
      "version": "2.0.0"
    }
  }
}

See demo: AndrewJanuary/pact-ruby-demo#1

[Mifrill]

📓 It will return an array even for a single record, so when we have only one message content, we show an array [content] in Contract, when we have multiple messages, we show an array of arrays [[Content]]

[Mifrill]

📝 matchingRules is still only for a single message

[YOU54F]

Thanks for the example

pact-spec v4, which is implemented in the rust core, supports synchronous messages, which may return an array of responses

https://github.com/pact-foundation/pact-specification/tree/version-4?tab=readme-ov-file#synchronousmessages

It works well on the consumer side, but on the provider side, on the first response method is verfied.

We would recommend migrating to rust core, and potentially proposing any changes there.

Appreciate the contribution, will be closing this off however, as this gem will go into maintainence mode soon, as we have migrated pact-ruby to the rust core

https://github.com/pact-foundation/pact-ruby/blob/master/documentation/README_V2.md