pact 1.67.5 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8be91a33981b95189c08f545d3746c76f2f2ad8642777f753cc3b414233986de
-  data.tar.gz: 1bc7d8a6e8a08c47b79e73f68e0caed9585a0eafb0bc316a4e589f2b3f9028a3
+  metadata.gz: ae64ff5080cc286c9a913c8ad1e06d99c35961f687eabe3e99c5bcaac6078aeb
+  data.tar.gz: 8fdbd4c74eb3e5c2cf57300ce269cb7e48f52fb83e5886f8e7aee08e97274d9a
 SHA512:
-  metadata.gz: a73f8cf2aa2956f7e0c7ed2dc8ab35fefbf1b7a2b0ab88d21bb3936a4761ae60d2fd622c4f2a767f2b6e75837556aeb055011667def9a90b8fbe1f9df74bf0f9
-  data.tar.gz: e27d62a8822b43ded6ccd48b926c2833292617834c7c2b8dda45d93a26a769d1093909d87921f8c15962445d3ef2012b1df2d5417ed7a07259a4275862c9f4b9
+  metadata.gz: 7b01cb166524d3fdc62d7a34ecacd922281d63885cb4cc48cc4ba3d4d5007511d5b2263b6697060cc443fda3efcdec45d2d54d182e6b9f1e9a9d9f3ac593cb36
+  data.tar.gz: acbf67bc8d3b23c85fbbcda46cdbf29297fd2eb859430536d58537ff055fb64ac4d6f9c28d6fee78324ebd33b9e534c6dd2e26dd454376dea9b8ea8aa28eb7e6

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+<a name="v2.0.1"></a>
+### v2.0.1 (2026-05-29)
+
+#### Bug Fixes
+
+* **example**
+  * remove combustion dependency from examples	 ([281b284](/../../commit/281b284))
+
+* align core_ext polyfills more closely with active_support implementations	 ([f08b8ce](/../../commit/f08b8ce))
+* correct Object#blank? and Object#present? polyfill implementations	 ([53580b9](/../../commit/53580b9))
+* add deep_dup polyfill alongside blank?/present?	 ([b116e14](/../../commit/b116e14))
+* remove hard requirements on active_support and webmock	 ([e77cd34](/../../commit/e77cd34))
+* support scalar request and response bodies in InteractionContents	 ([5440ed1](/../../commit/5440ed1))
+
+<a name="v2.0.0"></a>
+### v2.0.0 (2026-03-18)
+
+#### Features
+
+* **v2**
+  * move pact/v2 to pact namespace (#397)	 ([1cc97ec](/../../commit/1cc97ec))
+
 <a name="v1.67.5"></a>
 ### v1.67.5 (2026-02-13)
 

data/lib/pact/configuration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pact
+  class Configuration
+    attr_reader :before_provider_state_proc, :after_provider_state_proc
+
+    class GlobalProviderConfigurationError < ::Pact::Error; end
+
+    def before_provider_state_setup(&block)
+      raise GlobalProviderConfigurationError, 'no block given' unless block
+
+      @before_provider_state_proc = block
+    end
+
+    def after_provider_state_teardown(&block)
+      raise GlobalProviderConfigurationError, 'no block given' unless block
+
+      @after_provider_state_proc = block
+    end
+  end
+end

data/lib/pact/consumer/grpc_interaction_builder.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "pact/ffi/sync_message_consumer"
+require "pact/ffi/plugin_consumer"
+require "pact/ffi/logger"
+
+module Pact
+  module Consumer
+    class GrpcInteractionBuilder
+      CONTENT_TYPE = "application/protobuf"
+      GRPC_CONTENT_TYPE = "application/grpc"
+      PROTOBUF_PLUGIN_NAME = "protobuf"
+      PROTOBUF_PLUGIN_VERSION = "0.6.5"
+
+      class PluginInitError < Pact::FfiError; end
+
+      # https://docs.rs/pact_ffi/0.4.17/pact_ffi/plugins/fn.pactffi_using_plugin.html
+      INIT_PLUGIN_ERRORS = {
+        1 => {reason: :internal_error, status: 1, description: "A general panic was caught"},
+        2 => {reason: :plugin_load_failed, status: 2, description: "Failed to load the plugin"},
+        3 => {reason: :invalid_handle, status: 3, description: "Pact Handle is not valid"}
+      }.freeze
+
+      # https://docs.rs/pact_ffi/0.4.17/pact_ffi/plugins/fn.pactffi_interaction_contents.html
+      CREATE_INTERACTION_ERRORS = {
+        1 => {reason: :internal_error, status: 1, description: "A general panic was caught"},
+        2 => {reason: :mock_server_already_running, status: 2, description: "The mock server has already been started"},
+        3 => {reason: :invalid_handle, status: 3, description: "The interaction handle is invalid"},
+        4 => {reason: :invalid_content_type, status: 4, description: "The content type is not valid"},
+        5 => {reason: :invalid_contents, status: 5, description: "The contents JSON is not valid JSON"},
+        6 => {reason: :plugin_error, status: 6, description: "The plugin returned an error"}
+      }.freeze
+
+      class CreateInteractionError < Pact::FfiError; end
+
+      class InteractionMismatchesError < Pact::Error; end
+
+      class InteractionBuilderError < Pact::Error; end
+
+      def initialize(pact_config, description: nil)
+        @pact_config = pact_config
+        @description = description || ""
+        @proto_path = nil
+        @proto_include_dirs = []
+        @service_name = nil
+        @method_name = nil
+        @request = nil
+        @response = nil
+        @response_meta = nil
+        @provider_state_meta = nil
+      end
+
+      def with_service(proto_path, method, include_dirs = [])
+        raise InteractionBuilderError.new("invalid grpc method: cannot be blank") if method.blank?
+
+        service_name, method_name = method.split("/") || []
+        raise InteractionBuilderError.new("invalid grpc method: #{method}, should be like service/SomeMethod") if service_name.blank? || method_name.blank?
+
+        absolute_path = File.expand_path(proto_path)
+        raise InteractionBuilderError.new("proto file #{proto_path} does not exist") unless File.exist?(absolute_path)
+
+        @proto_path = absolute_path
+        @service_name = service_name
+        @method_name = method_name
+        @proto_include_dirs = include_dirs.map { |dir| File.expand_path(dir) }
+
+        self
+      end
+
+      def with_pact_protobuf_plugin_version(version)
+        raise InteractionBuilderError.new("version is required") if version.blank?
+
+        @proto_plugin_version = version
+        self
+      end
+
+      def given(provider_state, metadata = {})
+        @provider_state_meta = {provider_state => metadata}
+        self
+      end
+
+      def upon_receiving(description)
+        @description = description
+        self
+      end
+
+      def with_request(req_hash)
+        @request = InteractionContents.plugin(req_hash)
+        self
+      end
+
+      def will_respond_with(resp_hash)
+        @response = InteractionContents.plugin(resp_hash)
+        self
+      end
+
+      def will_respond_with_meta(meta_hash)
+        @response_meta = InteractionContents.plugin(meta_hash)
+        self
+      end
+
+      def interaction_json
+        result = {
+          "pact:proto": @proto_path,
+          "pact:proto-service": "#{@service_name}/#{@method_name}",
+          "pact:content-type": CONTENT_TYPE,
+          request: @request
+        }
+
+        result["pact:protobuf-config"] = {additionalIncludes: @proto_include_dirs} if @proto_include_dirs.present?
+
+        result[:response] = @response if @response.is_a?(Hash)
+        result[:responseMetadata] = @response_meta if @response_meta.is_a?(Hash)
+
+        JSON.dump(result)
+      end
+
+      def validate!
+        raise InteractionBuilderError.new("uninitialized service params, use #with_service to configure") if @proto_path.blank? || @service_name.blank? || @method_name.blank?
+        raise InteractionBuilderError.new("invalid request format, should be a hash") unless @request.is_a?(Hash)
+        raise InteractionBuilderError.new("invalid response format, should be a hash") unless @response.is_a?(Hash) || @response_meta.is_a?(Hash)
+      end
+
+      def execute(&block)
+        raise InteractionBuilderError.new("interaction is designed to be used one-time only") if defined?(@used)
+
+        validate!
+
+        pact_handle = init_pact
+        init_plugin!(pact_handle)
+
+        message_pact = PactFfi::SyncMessageConsumer.new_interaction(pact_handle, @description)
+        @provider_state_meta&.each_pair do |provider_state, meta|
+          if meta.present?
+            meta.each_pair { |k, v| PactFfi.given_with_param(message_pact, provider_state, k.to_s, v.to_s) }
+          else
+            PactFfi.given(message_pact, provider_state)
+          end
+        end
+
+        result = PactFfi::PluginConsumer.interaction_contents(message_pact, 0, GRPC_CONTENT_TYPE, interaction_json)
+        if CREATE_INTERACTION_ERRORS[result].present?
+          error = CREATE_INTERACTION_ERRORS[result]
+          raise CreateInteractionError.new("There was an error while trying to add interaction \"#{@description}\"", error[:reason], error[:status])
+        end
+
+        mock_server = MockServer.create_for_grpc!(pact: pact_handle, host: @pact_config.mock_host, port: @pact_config.mock_port)
+
+        yield(message_pact, mock_server)
+
+      ensure
+        if mock_server.matched?
+          mock_server.write_pacts!(@pact_config.pact_dir)
+        else
+          msg = mismatches_error_msg(mock_server)
+          raise InteractionMismatchesError.new(msg)
+        end
+        @used = true
+        mock_server&.cleanup
+        PactFfi::PluginConsumer.cleanup_plugins(pact_handle)
+        PactFfi.free_pact_handle(pact_handle)
+      end
+
+      private
+
+      def mismatches_error_msg(mock_server)
+        rspec_example_desc = RSpec.current_example&.description
+        return "interaction for #{@service_name}/#{@method_name} has mismatches: #{mock_server.mismatches}" if rspec_example_desc.blank?
+
+        "#{rspec_example_desc} has mismatches: #{mock_server.mismatches}"
+      end
+
+      def init_pact
+        handle = PactFfi.new_pact(@pact_config.consumer_name, @pact_config.provider_name)
+        PactFfi.with_specification(handle, PactFfi::FfiSpecificationVersion["SPECIFICATION_VERSION_V4"])
+        PactFfi.with_pact_metadata(handle, "pact-ruby", "pact-ffi", PactFfi.version)
+
+        Pact::Native::Logger.log_to_stdout(@pact_config.log_level)
+
+        handle
+      end
+
+      def init_plugin!(pact_handle)
+        result = PactFfi::PluginConsumer.using_plugin(pact_handle, PROTOBUF_PLUGIN_NAME, @proto_plugin_version || PROTOBUF_PLUGIN_VERSION)
+        return result if INIT_PLUGIN_ERRORS[result].blank?
+
+        error = INIT_PLUGIN_ERRORS[result]
+        raise PluginInitError.new("There was an error while trying to initialize plugin #{PROTOBUF_PLUGIN_NAME}/#{@proto_plugin_version || PROTOBUF_PLUGIN_VERSION}", error[:reason], error[:status])
+      end
+    end
+  end
+end

data/lib/pact/consumer/http_interaction_builder.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "pact/ffi/sync_message_consumer"
+require "pact/ffi/plugin_consumer"
+require "pact/ffi/logger"
+require "json"
+
+module Pact
+  module Consumer
+    class HttpInteractionBuilder
+
+      # https://docs.rs/pact_ffi/0.4.17/pact_ffi/plugins/fn.pactffi_interaction_contents.html
+      CREATE_INTERACTION_ERRORS = {
+        1 => {reason: :internal_error, status: 1, description: "A general panic was caught"},
+        2 => {reason: :mock_server_already_running, status: 2, description: "The mock server has already been started"},
+        3 => {reason: :invalid_handle, status: 3, description: "The interaction handle is invalid"},
+        4 => {reason: :invalid_content_type, status: 4, description: "The content type is not valid"},
+        5 => {reason: :invalid_contents, status: 5, description: "The contents JSON is not valid JSON"},
+        6 => {reason: :plugin_error, status: 6, description: "The plugin returned an error"}
+      }.freeze
+
+      class CreateInteractionError < Pact::FfiError; end
+
+      class InteractionMismatchesError < Pact::Error; end
+
+      class InteractionBuilderError < Pact::Error; end
+
+      class << self
+        def create_finalizer(pact_handle)
+          proc { PactFfi.free_pact_handle(pact_handle) }
+        end
+      end
+
+      def initialize(pact_config, description: nil)
+        @pact_config = pact_config
+        @description = description || ""
+
+        @pact_handle = pact_config.pact_handle ||= init_pact
+        @pact_interaction = PactFfi.new_interaction(pact_handle, @description)
+
+        ObjectSpace.define_finalizer(self, self.class.create_finalizer(pact_interaction))
+      end
+
+      def given(provider_state, metadata = {})
+        if metadata.present?
+          PactFfi.given_with_params(pact_interaction, provider_state, JSON.dump(metadata))
+        else
+          PactFfi.given(pact_interaction, provider_state)
+        end
+
+        self
+      end
+
+      def upon_receiving(description)
+        @description = description
+        PactFfi.upon_receiving(pact_interaction, @description)
+        self
+      end
+
+      def with_request(method: nil, path: nil, query: {}, headers: {}, body: nil)
+        interaction_part = PactFfi::FfiInteractionPart["INTERACTION_PART_REQUEST"]
+        PactFfi.with_request(pact_interaction, method.to_s, format_value(path))
+
+        # Processing as an array of hashes, allows us to consider duplicate keys
+        # which should be passed to the core, at a non 0 index
+        if query.is_a?(Array)
+          key_index = Hash.new(0)
+          query.each do |query_item|
+            InteractionContents.basic(query_item).each_pair do |key, value_item|
+              PactFfi.with_query_parameter_v2(pact_interaction, key.to_s, key_index[key], format_value(value_item))
+              key_index[key] += 1
+            end
+          end
+        else
+          InteractionContents.basic(query).each_pair do |key, value_item|
+            PactFfi.with_query_parameter_v2(pact_interaction, key.to_s, 0, format_value(value_item))
+          end
+        end
+
+        InteractionContents.basic(headers).each_pair do |key, value_item|
+          PactFfi.with_header_v2(pact_interaction, interaction_part, key.to_s, 0, format_value(value_item))
+        end
+
+        if body
+          PactFfi.with_body(pact_interaction, interaction_part, "application/json", format_value(InteractionContents.basic(body).value))
+        end
+
+        self
+      end
+
+      def will_respond_with(status: nil, headers: {}, body: nil)
+        interaction_part = PactFfi::FfiInteractionPart["INTERACTION_PART_RESPONSE"]
+        PactFfi.response_status(pact_interaction, status)
+
+        InteractionContents.basic(headers).each_pair do |key, value_item|
+          PactFfi.with_header_v2(pact_interaction, interaction_part, key.to_s, 0, format_value(value_item))
+        end
+
+        if body
+          PactFfi.with_body(pact_interaction, interaction_part, "application/json", format_value(InteractionContents.basic(body).value))
+        end
+
+        self
+      end
+
+      def execute(&block)
+        raise InteractionBuilderError.new("interaction is designed to be used one-time only") if defined?(@used)
+
+        mock_server = MockServer.create_for_http!(
+          pact: pact_handle, host: pact_config.mock_host, port: pact_config.mock_port
+        )
+
+        yield(mock_server)
+
+      ensure
+        if mock_server.matched?
+          mock_server.write_pacts!(pact_config.pact_dir)
+        else
+          msg = mismatches_error_msg(mock_server)
+          raise InteractionMismatchesError.new(msg)
+        end
+        @used = true
+        mock_server&.cleanup
+        # Reset the pact handle to allow for a new interaction to be built
+        # without previous interactions being included
+        @pact_config.reset_pact
+      end
+
+      private
+
+      attr_reader :pact_handle, :pact_interaction, :pact_config
+
+      def mismatches_error_msg(mock_server)
+        rspec_example_desc = RSpec.current_example&.description
+        mismatches = JSON.pretty_generate(JSON.parse(mock_server.mismatches))
+        mismatches_with_colored_keys = mismatches.gsub(/"([^"]+)":/) { |match| "\e[34m#{match}\e[0m" } # Blue keys / white values
+
+        "#{rspec_example_desc} has mismatches: #{mismatches_with_colored_keys}"
+      end
+
+      def init_pact
+        handle = PactFfi.new_pact(pact_config.consumer_name, pact_config.provider_name)
+        PactFfi.with_specification(handle, PactFfi::FfiSpecificationVersion["SPECIFICATION_VERSION_#{pact_config.pact_specification}"])
+        PactFfi.with_pact_metadata(handle, "pact-ruby", "pact-ffi", PactFfi.version)
+
+        Pact::Native::Logger.log_to_stdout(pact_config.log_level)
+
+        handle
+      end
+
+      def format_value(obj)
+        return obj if obj.is_a?(String)
+
+        return JSON.dump({value: obj}) if obj.is_a?(Array)
+
+        JSON.dump(obj)
+      end
+    end
+  end
+end

data/lib/pact/consumer/interaction_contents.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pact
+  module Consumer
+    class InteractionContents < Hash
+      BASIC_FORMAT = :basic
+      PLUGIN_FORMAT = :plugin
+
+      attr_reader :format
+
+      def self.basic(contents_hash)
+        new(contents_hash, BASIC_FORMAT)
+      end
+
+      def self.plugin(contents_hash)
+        new(contents_hash, PLUGIN_FORMAT)
+      end
+
+      def initialize(contents_hash, format)
+        serialized = init_hash(contents_hash, format)
+        # A scalar body (plain string, integer, etc.) serializes to a non-Hash
+        # value that cannot be merged pair by pair; expose it via #value instead.
+        if serialized.is_a?(Hash)
+          serialized.each_pair { |k, v| self[k] = v }
+        else
+          @value = serialized
+        end
+        @format = format
+      end
+
+      def value
+        defined?(@value) ? @value : self
+      end
+
+      private
+
+      def serialize(hash, format)
+        # serialize recursively
+        if hash.is_a?(Pact::Matchers::Base) || hash.is_a?(Pact::Generators::Base)
+          return hash.as_basic if format == :basic
+          return hash.as_plugin if format == :plugin
+        end
+
+        return hash.map { |value| serialize(value, format) } if hash.is_a?(Array)
+
+        # A value that is not a collection or a matcher/generator has nothing to
+        # recurse into, so return it unchanged (string, integer, boolean, nil, ...).
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_pair do |key, value|
+          hash[key] = serialize(value, format)
+        end
+
+        hash
+      end
+
+      def init_hash(hash, format)
+        serialize(hash.deep_dup, format)
+      end
+    end
+  end
+end