pact 1.66.2 → 1.67.0

data/lib/pact/v2/matchers/v3/semver.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Semver < Pact::V2::Matchers::Base
+          def initialize(template = nil)
+            @template = template
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "semver", template: template)
+          end
+
+          def as_plugin
+            if @template.nil? || @template.blank?
+              raise MatcherInitializationError, "#{self.class}: template must be provided when calling as_plugin"
+            end
+            "matching(semver, '#{@template}')"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Time < Pact::V2::Matchers::Base
+          def initialize(format, template)
+            raise MatcherInitializationError, "#{self.class}: #{format} should be an instance of String" unless template.is_a?(String)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "time", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/values.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Values < Pact::V2::Matchers::Base
+          def initialize
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "values", template: nil)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/each_key.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class EachKey < Pact::V2::Matchers::Base
+          def initialize(key_matchers, template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be an Array" unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be instances of Pact::V2::Matchers::Base" unless key_matchers.all?(Pact::V2::Matchers::Base)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} size should be greater than 0" unless key_matchers.size > 0
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: "each-key", template: template, opts: {rules: key_matchers})
+          end
+
+          def as_plugin
+            @opts[:rules].map do |matcher|
+              "eachKey(#{matcher.as_plugin})"
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/each_key_value.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class EachKeyValue < Pact::V2::Matchers::Base
+          def initialize(key_matchers, template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be an Array" unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be instances of Pact::V2::Matchers::Base" unless key_matchers.all?(Pact::V2::Matchers::Base)
+
+            super(
+              spec_version: Pact::V2::Matchers::PACT_SPEC_V4,
+              kind: [
+                EachKey.new(key_matchers, {}),
+                EachValue.new([Pact::V2::Matchers::V2::Type.new("")], {})
+              ],
+              template: template
+            )
+
+            @key_matchers = key_matchers
+          end
+
+          def as_plugin
+            raise MatcherInitializationError, "#{self.class}: each-key-value is not supported in plugin syntax. Use each / each_key / each_value matchers instead"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/each_value.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class EachValue < Pact::V2::Matchers::Base
+          def initialize(value_matchers, template)
+            # raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} should be an Array" unless value_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} should be instances of Pact::V2::Matchers::Base" unless value_matchers.all?(Pact::V2::Matchers::Base)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} size should be greater than 0" unless value_matchers.size > 0
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: "each-value", template: template, opts: {rules: value_matchers})
+          end
+
+          def as_plugin
+            if @template.is_a?(Hash)
+              return {
+                "pact:match" => "eachValue(matching($'SAMPLE'))",
+                "SAMPLE" => serialize!(@template.deep_dup, :plugin)
+              }
+            end
+
+            @opts[:rules].map do |matcher|
+              "eachValue(#{matcher.as_plugin})"
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/not_empty.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class NotEmpty < Pact::V2::Matchers::Base
+          def initialize(template = nil)
+            @template = template
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: 'notEmpty', template: @template)
+          end
+
+          def as_plugin
+            if @template.nil? || @template.blank?
+              raise MatcherInitializationError, "#{self.class}: template must be provided when calling as_plugin"
+            end
+
+            "notEmpty('#{@template}')"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/status_code.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class StatusCode < Pact::V2::Matchers::Base
+          def initialize(template = nil)
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: 'statusCode', opts: {
+              'status' => template
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      PACT_SPEC_V1 = 1
+      PACT_SPEC_V2 = 2
+      PACT_SPEC_V3 = 3
+      PACT_SPEC_V4 = 4
+
+      ANY_STRING_REGEX = /.*/
+      UUID_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+
+      # simplified
+      ISO8601_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)*(.\d{2}:\d{2})*/i
+
+      def match_exactly(arg)
+        V1::Equality.new(arg)
+      end
+
+      def match_type_of(arg)
+        V2::Type.new(arg)
+      end
+
+      def match_include(arg)
+        V3::Include.new(arg)
+      end
+
+      def match_any_string(sample = "any")
+        V2::Regex.new(ANY_STRING_REGEX, sample)
+      end
+
+      def match_any_integer(sample = 10)
+        V3::Integer.new(sample)
+      end
+
+      def match_any_decimal(sample = 10.0)
+        V3::Decimal.new(sample)
+      end
+
+      def match_any_number(sample = 10.0)
+        V3::Number.new(sample)
+      end
+
+      def match_any_boolean(sample = true)
+        V3::Boolean.new(sample)
+      end
+
+      def match_uuid(sample = "e1d01e04-3a2b-4eed-a4fb-54f5cd257338")
+        V2::Regex.new(UUID_REGEX, sample)
+      end
+
+      def match_regex(regex, sample)
+        V2::Regex.new(regex, sample)
+      end
+
+      def match_datetime(format, sample)
+        V3::DateTime.new(format, sample)
+      end
+
+      def match_iso8601(sample = "2024-08-12T12:25:00.243118+03:00")
+        V2::Regex.new(ISO8601_REGEX, sample)
+      end
+
+      def match_date(format, sample)
+        V3::Date.new(format, sample)
+      end
+
+      def match_time(format, sample)
+        V3::Time.new(format, sample)
+      end
+
+      def match_each(template, min = nil)
+        V3::Each.new(template, min)
+      end
+
+      def match_each_regex(regex, sample)
+        match_each_value(sample, match_regex(regex, sample))
+      end
+
+      def match_each_key(template, key_matchers)
+        V4::EachKey.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+      end
+
+      def match_each_value(template, value_matchers = V2::Type.new(""))
+        V4::EachValue.new(value_matchers.is_a?(Array) ? value_matchers : [value_matchers], template)
+      end
+
+      def match_each_kv(template, key_matchers)
+        V4::EachKeyValue.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+      end
+
+      def match_semver(template = nil)
+        V3::Semver.new(template)
+      end
+
+      def match_content_type(content_type, template = nil)
+        V3::ContentType.new(content_type, template: template)
+      end
+
+      def match_not_empty(template = nil)
+        V4::NotEmpty.new(template)
+      end
+
+      def match_status_code(template)
+        V4::StatusCode.new(template)
+      end
+    end
+  end
+end

data/lib/pact/v2/native/blocking_verifier.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "pact/ffi/verifier"
+
+module Pact
+  module V2
+    module Native
+      module BlockingVerifier
+        extend FFI::Library
+        ffi_lib DetectOS.get_bin_path
+
+        attach_function :execute, :pactffi_verifier_execute, %i[pointer], :int32, blocking: true
+      end
+    end
+  end
+end

data/lib/pact/v2/native/logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "pact/ffi/logger"
+
+module Pact
+  module V2
+    module Native
+      module Logger
+        LOG_LEVELS = {
+          off: PactFfi::FfiLogLevelFilter["LOG_LEVEL_OFF"],
+          error: PactFfi::FfiLogLevelFilter["LOG_LEVEL_ERROR"],
+          warn: PactFfi::FfiLogLevelFilter["LOG_LEVEL_WARN"],
+          info: PactFfi::FfiLogLevelFilter["LOG_LEVEL_INFO"],
+          debug: PactFfi::FfiLogLevelFilter["LOG_LEVEL_DEBUG"],
+          trace: PactFfi::FfiLogLevelFilter["LOG_LEVEL_TRACE"]
+        }.freeze
+
+        def self.log_to_stdout(log_level)
+          raise "invalid log level for PactFfi::FfiLogLevelFilter" unless LOG_LEVELS.key?(log_level)
+          PactFfi::Logger.log_to_stdout(LOG_LEVELS[log_level])
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/provider/async_message_verifier.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "pact/v2/native/logger"
+
+module Pact
+  module V2
+    module Provider
+      class AsyncMessageVerifier < BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = "message"
+
+        def initialize(pact_config, mixed_config = nil)
+          super
+
+          raise ArgumentError, "pact_config must be an instance of Pact::V2::Provider::PactConfig::Message" unless pact_config.is_a?(::Pact::V2::Provider::PactConfig::Async)
+        end
+
+        private
+
+        def add_provider_transport(pact_handle)
+          setup_uri = URI(@pact_config.message_setup_url)
+          PactFfi::Verifier.add_provider_transport(pact_handle, PROVIDER_TRANSPORT_TYPE, setup_uri.port, setup_uri.path, "")
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/v2/provider/base_verifier.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "pact/v2/native/logger"
+require "pact/v2/native/blocking_verifier"
+
+module Pact
+  module V2
+    module Provider
+      class BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = nil
+        attr_reader :logger
+
+        class VerificationError < Pact::V2::FfiError; end
+
+        class VerifierError < Pact::V2::Error; end
+
+        DEFAULT_CONSUMER_SELECTORS = {}
+
+        # https://docs.rs/pact_ffi/0.4.17/pact_ffi/verifier/fn.pactffi_verify.html#errors
+        VERIFICATION_ERRORS = {
+          1 => {reason: :verification_failed, status: 1, description: "The verification process failed, see output for errors"},
+          2 => {reason: :null_pointer, status: 2, description: "A null pointer was received"},
+          3 => {reason: :internal_error, status: 3, description: "The method panicked"},
+          4 => {reason: :invalid_arguments, status: 4, description: "Invalid arguments were provided to the verification process"}
+        }.freeze
+
+        # env below are set up by pipeline-builder
+        # see paas/cicd/images/pact/pipeline-builder/-/blob/master/internal/commands/consumers-pipeline/ruby.go
+        def initialize(pact_config, mixed_config = nil)
+          raise ArgumentError, "pact_config must be a subclass of Pact::V2::Provider::PactConfig::Base" unless pact_config.is_a?(::Pact::V2::Provider::PactConfig::Base)
+          @pact_config = pact_config
+          @mixed_config = mixed_config
+          @logger = Logger.new($stdout)
+        end
+
+        def verify!
+          raise VerifierError.new("interaction is designed to be used one-time only") if defined?(@used)
+
+          # if consumer_selectors.blank?
+          #   logger.info("[verifier] does not need to verify consumer #{@pact_config.consumer_name}")
+          #   return
+          # end
+
+          exception = nil
+          pact_handle = init_pact
+
+          start_servers!
+
+          logger.info("[verifier] starting provider verification")
+
+          result = Pact::V2::Native::BlockingVerifier.execute(pact_handle)
+          if VERIFICATION_ERRORS[result].present?
+            error = VERIFICATION_ERRORS[result]
+            exception = VerificationError.new("There was an error while trying to verify provider \"#{@pact_config.provider_name}\"", error[:reason], error[:status])
+          end
+        ensure
+          @used = true
+          PactFfi::Verifier.shutdown(pact_handle) if pact_handle
+          stop_servers
+          @grpc_server.stop if @grpc_server
+          raise exception if exception
+        end
+
+        private
+
+        def create_c_pointer_array_from_string_array(string_array)
+          pointers = string_array.map { |str| FFI::MemoryPointer.from_string(str) }
+          array_pointer = FFI::MemoryPointer.new(:pointer, pointers.size)
+          pointers.each_with_index do |ptr, index|
+            array_pointer[index].put_pointer(0, ptr)
+          end
+          array_pointer
+        end
+
+        def bool_to_int(value)
+          value ? 1 : 0
+        end
+
+        def init_pact
+          handle = PactFfi::Verifier.new_for_application("pact-ruby-v2", PactFfi.version)
+          set_provider_info(handle)
+
+          if defined?(@mixed_config.grpc_config) && @mixed_config.grpc_config
+            @grpc_server = GrufServer.new(host: "127.0.0.1:#{@mixed_config.grpc_config.grpc_port}", services: @mixed_config.grpc_config.grpc_services)
+            @grpc_server.start
+            PactFfi::Verifier.add_provider_transport(handle, "grpc", @mixed_config.grpc_config.grpc_port, "", "")
+          end
+
+          if defined?(@mixed_config.async_config) && @mixed_config.async_config
+            setup_uri = URI(@mixed_config.async_config.message_setup_url)
+            PactFfi::Verifier.add_provider_transport(handle, "message", setup_uri.port, setup_uri.path, "")
+          end
+
+          # todo: add http transport?
+
+          PactFfi::Verifier.set_provider_state(handle, @pact_config.provider_setup_url, 1, 1)
+          PactFfi::Verifier.set_verification_options(handle, 0, 10000)
+          # pactffi_verifier_set_publish_options(
+          #     handle: *mut VerifierHandle,
+          #     provider_version: *const c_char,
+          #     build_url: *const c_char,
+          #     provider_tags: *const *const c_char,
+          #     provider_tags_len: c_ushort,
+          #     provider_branch: *const c_char,
+          # )
+          c_provider_version_tags = create_c_pointer_array_from_string_array(@pact_config.provider_version_tags)
+          c_provider_version_tags_size = @pact_config.provider_version_tags.size
+          c_consumer_version_tags = create_c_pointer_array_from_string_array(@pact_config.consumer_version_tags)
+          c_consumer_version_tags_size = @pact_config.consumer_version_tags.size
+
+          if @pact_config.provider_build_uri.present?
+            begin
+              URI.parse(@pact_config.provider_build_uri)
+            rescue URI::InvalidURIError
+              raise VerifierError.new("provider_build_uri is not a valid URI")
+            end
+          end
+
+          if @pact_config.publish_verification_results == true
+            if @pact_config.provider_version
+              PactFfi::Verifier.set_publish_options(handle, @pact_config.provider_version, @pact_config.provider_build_uri, c_provider_version_tags, c_provider_version_tags_size, @pact_config.provider_version_branch)
+            else
+              logger.warn("[verifier] - unable to publish verification results as provider version is not set")
+            end
+          end
+
+          configure_verification_source(handle, c_provider_version_tags, c_provider_version_tags_size, c_consumer_version_tags, c_consumer_version_tags_size)
+
+          PactFfi::Verifier.set_no_pacts_is_error(handle, bool_to_int(@pact_config.fail_if_no_pacts_found))
+
+          add_provider_transport(handle)
+
+          # the core doesnt pick up these env vars, so we need to set them here
+          # https://github.com/pact-foundation/pact-reference/issues/451#issuecomment-2338130587
+          # PACT_DESCRIPTION
+          # Only validate interactions whose descriptions match this filter (regex format)
+          # PACT_PROVIDER_STATE
+          # Only validate interactions whose provider states match this filter (regex format)
+          # PACT_PROVIDER_NO_STATE
+          # Only validate interactions that have no defined provider state (true or false)
+          PactFfi::Verifier.set_filter_info(
+            handle,
+            ENV["PACT_DESCRIPTION"] || nil,
+            ENV["PACT_PROVIDER_STATE"] || nil,
+            bool_to_int(ENV["PACT_PROVIDER_NO_STATE"] || false)
+          )
+
+          Pact::V2::Native::Logger.log_to_stdout(@pact_config.log_level)
+
+          logger.info("[verifier] verification initialized for provider #{@pact_config.provider_name}, version #{@pact_config.provider_version}, transport #{self.class::PROVIDER_TRANSPORT_TYPE}")
+
+          handle
+        end
+
+        def set_provider_info(pact_handle)
+          #   pub extern "C" fn pactffi_verifier_set_provider_info(
+          #     handle: *mut VerifierHandle,
+          #     name: *const c_char,
+          #     scheme: *const c_char,
+          #     host: *const c_char,
+          #     port: c_ushort,
+          #     path: *const c_char,
+          # ) {
+          PactFfi::Verifier.set_provider_info(pact_handle, @pact_config.provider_name, "", "", 0, "")
+        end
+
+        def add_provider_transport(pact_handle)
+          raise Pact::V2::ImplementationRequired, "Implement #add_provider_transport in a subclass"
+        end
+
+        def start_servers!
+          logger.info("[verifier] starting services")
+
+          @servers_started = true
+          @pact_config.start_servers
+        end
+
+        def stop_servers
+          return unless @servers_started
+
+          logger.info("[verifier] stopping services")
+
+          @pact_config.stop_servers
+        end
+
+        def configure_verification_source(handle, c_provider_version_tags, c_provider_version_tags_size, c_consumer_version_tags, c_consumer_version_tags_size)
+          logger.info("[verifier] configuring verification source")
+          if @pact_config.pact_broker_proxy_url.blank? && @pact_config.pact_uri.blank?
+            # todo support non rail apps
+            path = @pact_config.pact_dir || (defined?(Rails) ? Rails.root.join("pacts").to_s : "pacts")
+            logger.info("[verifier] pact broker url or pact uri is not set, using directory #{path} as a verification source")
+            return PactFfi::Verifier.add_directory_source(handle, path)
+          end
+
+          if @pact_config.pact_uri.present?
+            if @pact_config.pact_uri.start_with?("http")
+              logger.info("[verifier] using pact uri #{@pact_config.pact_uri} as a verification source")
+              PactFfi::Verifier.url_source(handle, @pact_config.pact_uri, @pact_config.broker_username, @pact_config.broker_password, @pact_config.broker_token)
+            else
+              logger.info("[verifier] using pact file #{@pact_config.pact_uri} as a verification source")
+              PactFfi::Verifier.add_file_source(handle, @pact_config.pact_uri)
+            end
+          else
+            logger.info("[verifier] using pact broker url #{@pact_config.broker_url} with consumer selectors: #{JSON.dump(consumer_selectors)} as a verification source")
+            consumer_selectors = [] if consumer_selectors.nil?
+            filters = consumer_selectors.map do |selector|
+              FFI::MemoryPointer.from_string(JSON.dump(selector).to_s)
+            end
+            filters_ptr = FFI::MemoryPointer.new(:pointer, filters.size + 1)
+            filters_ptr.write_array_of_pointer(filters)
+            PactFfi::Verifier.broker_source_with_selectors(handle, @pact_config.pact_broker_proxy_url, @pact_config.broker_username, @pact_config.broker_password, @pact_config.broker_token, bool_to_int(@pact_config.enable_pending), @pact_config.include_wip_pacts_since, c_provider_version_tags, c_provider_version_tags_size, @pact_config.provider_version_branch, filters_ptr, consumer_selectors.size, c_consumer_version_tags, c_consumer_version_tags_size)
+          end
+        end
+
+        def consumer_selectors
+          (!@pact_config.consumer_version_selectors.empty? && @pact_config.consumer_version_selectors) || @consumer_selectors if @pact_config.consumer_version_selectors
+        end
+
+        def build_consumer_selectors(verify_only, consumer_name, consumer_branch)
+          # if verify_only and consumer_name are defined - select only needed consumer
+          if verify_only.present?
+            # select proper consumer branch if defined
+            if consumer_name.present?
+              return [] unless verify_only.include?(consumer_name)
+              return [{"branch" => consumer_branch, "consumer" => consumer_name}] if consumer_branch.present?
+              return [DEFAULT_CONSUMER_SELECTORS.merge("consumer" => consumer_name)]
+            end
+            # or default selectors
+            return verify_only.map { |name| DEFAULT_CONSUMER_SELECTORS.merge("consumer" => name) }
+          end
+
+          # select provided consumer_name
+          return [{"branch" => consumer_branch, "consumer" => consumer_name}] if consumer_name.present? && consumer_branch.present?
+          return [DEFAULT_CONSUMER_SELECTORS.merge("consumer" => consumer_name)] if consumer_name.present?
+
+          [DEFAULT_CONSUMER_SELECTORS]
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/provider/grpc_verifier.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "pact/v2/native/logger"
+
+module Pact
+  module V2
+    module Provider
+      class GrpcVerifier < BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = "grpc"
+
+        def initialize(pact_config, mixed_config = nil)
+          super
+
+          raise ArgumentError, "pact_config must be an instance of Pact::V2::Provider::PactConfig::Grpc" unless pact_config.is_a?(::Pact::V2::Provider::PactConfig::Grpc)
+          @grpc_server = GrufServer.new(host: "127.0.0.1:#{@pact_config.grpc_port}", services: @pact_config.grpc_services)
+        end
+
+        private
+
+        def add_provider_transport(pact_handle)
+          PactFfi::Verifier.add_provider_transport(pact_handle, PROVIDER_TRANSPORT_TYPE, @pact_config.grpc_port, "", "")
+        end
+
+
+        def start_servers!
+          super
+          @grpc_server.start
+        end
+
+        def stop_servers
+          super
+          @grpc_server.stop
+        end
+      end
+    end
+  end
+end