pact 1.66.1 → 1.67.0

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# require_relative "pact_config/grpc"
+
+module Pact
+  module V2
+    module Provider
+      module PactConfig
+        def self.new(transport_type, provider_name:, opts: {})
+          case transport_type
+          when :http
+            Http.new(provider_name: provider_name, opts: opts)
+          when :grpc
+            Grpc.new(provider_name: provider_name, opts: opts)
+          when :async
+            Async.new(provider_name: provider_name, opts: opts)
+          when :mixed
+            Mixed.new(provider_name: provider_name, opts: opts)
+          else
+            raise ArgumentError, "unknown transport_type: #{transport_type}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  module V2
+    module Provider
+      class ProviderServerRunner
+        attr_reader :logger
+
+        SETUP_PROVIDER_STATE_PATH = "/setup-provider"
+        VERIFY_MESSAGE_PATH = "/verify-message"
+
+        def initialize(port: 9001, host: "127.0.0.1", logger: nil)
+          @host = host
+          @port = port
+          @provider_setup_states = {}
+          @provider_teardown_states = {}
+          @logger = logger || Logger.new($stdout)
+
+          @state_servlet = ProviderStateServlet.new(logger: @logger)
+          @message_servlet = MessageProviderServlet.new(logger: @logger)
+          @thread = nil
+        end
+
+        def state_setup_url
+          "http://#{@host}:#{@port}#{SETUP_PROVIDER_STATE_PATH}"
+        end
+
+        def message_setup_url
+          "http://#{@host}:#{@port}#{VERIFY_MESSAGE_PATH}"
+        end
+
+        def start
+          raise "server already running, stop server before starting new one" if @thread
+
+          @server = WEBrick::HTTPServer.new({BindAddress: @host, Port: @port}, WEBrick::Config::HTTP)
+          @server.mount(SETUP_PROVIDER_STATE_PATH, @state_servlet)
+          @server.mount(VERIFY_MESSAGE_PATH, @message_servlet)
+
+          @thread = Thread.new do
+            @logger.debug "starting provider setup server"
+            @server.start
+          end
+        end
+
+        def stop
+          @logger.info("stopping provider setup server")
+
+          @server&.shutdown
+          @thread&.join
+
+          @logger.info("provider setup server stopped")
+        end
+
+        def run
+          start
+
+          yield
+        rescue => e
+          logger.fatal("FATAL ERROR: #{e.message} #{e.backtrace.join("\n")}")
+          raise
+        ensure
+          stop
+        end
+
+        def add_message_handler(state_name, &block)
+          @message_servlet.add_message_handler(state_name, &block)
+        end
+
+        def add_setup_state(state_name, use_before_setup_hook = true, &block)
+          @state_servlet.add_setup_state(state_name, use_before_setup_hook, &block)
+        end
+
+        def add_teardown_state(state_name, use_after_teardown_hook = true, &block)
+          @state_servlet.add_teardown_state(state_name, use_after_teardown_hook, &block)
+        end
+
+        def set_before_setup_hook(&block)
+          @state_servlet.before_setup(&block)
+        end
+
+        def set_after_teardown_hook(&block)
+          @state_servlet.after_teardown(&block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Provider
+      class ProviderStateConfiguration
+        attr_reader :name, :opts, :setup_proc, :teardown_proc
+
+        class ProviderStateConfigurationError < ::Pact::V2::Error; end
+
+        def initialize(name, opts: {})
+          @name = name
+          @opts = opts
+          @setup_proc = nil
+          @teardown_proc = nil
+        end
+
+        def set_up(&block)
+          @setup_proc = block
+        end
+
+        def tear_down(&block)
+          @teardown_proc = block
+        end
+
+        def validate!
+          raise ProviderStateConfigurationError.new("no hooks configured for state #{@name}: \"provider_state\" declaration only needed if setup/teardown hooks are used for that state. Please add hooks or remove \"provider_state\" declaration") unless @setup_proc || @teardown_proc
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  module V2
+    module Provider
+      class ProviderStateServlet < WEBrick::HTTPServlet::ProcHandler
+        attr_reader :logger
+
+        def initialize(logger: Logger.new($stdout))
+          super(build_proc)
+
+          @logger = logger
+
+          @provider_setup_states = {}
+          @provider_teardown_states = {}
+
+          @before_setup_hook_proc = nil
+          @after_teardown_hook_proc = nil
+
+          @global_setup_hook = ::Pact::V2.configuration.before_provider_state_proc
+          @global_teardown_hook = ::Pact::V2.configuration.after_provider_state_proc
+        end
+
+        def add_setup_state(name, use_before_setup_hook, &block)
+          raise "provider state #{name} already configured" if @provider_setup_states[name].present?
+
+          @provider_setup_states[name] = {proc: block, use_hooks: use_before_setup_hook}
+        end
+
+        def add_teardown_state(name, use_after_teardown_hook, &block)
+          raise "provider state #{name} already configured" if @provider_teardown_states[name].present?
+
+          @provider_teardown_states[name] = {proc: block, use_hooks: use_after_teardown_hook}
+        end
+
+        def before_setup(&block)
+          @before_setup_hook_proc = block
+        end
+
+        def after_teardown(&block)
+          @after_teardown_hook_proc = block
+        end
+
+        private
+
+        def call_setup(state_name, state_data)
+          logger.debug "call_setup #{state_name} with #{state_data}"
+          @global_setup_hook&.call
+          @before_setup_hook_proc&.call(state_name, state_data) if @provider_setup_states.dig(state_name, :use_hooks)
+          @provider_setup_states.dig(state_name, :proc)&.call(state_data)
+        end
+
+        def call_teardown(state_name, state_data)
+          logger.debug "call_teardown #{state_name} with #{state_data}"
+          @provider_teardown_states.dig(state_name, :proc)&.call(state_data)
+          @after_teardown_hook_proc&.call(state_name, state_data) if @provider_setup_states.dig(state_name, :use_hooks)
+          @global_teardown_hook&.call
+        end
+
+        def build_proc
+          proc do |request, response|
+            # {"action" => "setup", "params" => {"order_uuid" => "mxfcpcsfUOHO"},"state" => "order exists and can be saved"}
+            # {"action"=> "teardown", "params" => {"order_uuid" => "mxfcpcsfUOHO"}, "state" => "order exists and can be saved"}
+            data = JSON.parse(request.body)
+
+            action = data["action"]
+            state_name = data["state"]
+            state_data = data["params"]
+
+            logger.warn("unknown callback state action: #{action}") if action.blank?
+
+            call_setup(state_name, state_data) if action == "setup"
+            call_teardown(state_name, state_data) if action == "teardown"
+
+            response.status = 200
+          rescue JSON::ParserError => ex
+            logger.error("cannot parse request: #{ex.message}")
+            response.status = 500
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/provider.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Provider
+    end
+  end
+end

data/lib/pact/v2/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Pact
+  module V2
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load "pact/v2/tasks/pact.rake"
+      end
+    end
+  end
+end

data/lib/pact/v2/rspec/support/pact_consumer_helpers.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "pact_message_helpers"
+require "json"
+
+module PactV2ConsumerDsl
+  include Pact::V2::Matchers
+  include Pact::V2::Generators
+
+  module ClassMethods
+    def has_http_pact_between(consumer, provider, opts: {})
+      _has_pact_between(:http, consumer, provider, opts: opts)
+    end
+
+    def has_grpc_pact_between(consumer, provider, opts: {})
+      _has_pact_between(:grpc, consumer, provider, opts: opts)
+    end
+
+    def has_message_pact_between(consumer, provider, opts: {})
+      _has_pact_between(:message, consumer, provider, opts: opts)
+    end
+
+    def has_plugin_http_pact_between(consumer, provider, opts: {})
+      _has_pact_between(:plugin_http, consumer, provider, opts: opts)
+    end
+
+    def has_plugin_sync_message_pact_between(consumer, provider, opts: {})
+      _has_pact_between(:plugin_sync_message, consumer, provider, opts: opts)
+    end
+
+    def has_plugin_async_message_pact_between(consumer, provider, opts: {})
+      _has_pact_between(:plugin_async_message, consumer, provider, opts: opts)
+    end
+
+    def _has_pact_between(transport_type, consumer, provider, opts: {})
+      raise "has_#{transport_type}_pact_between is designed to be used with RSpec 3+" unless defined?(::RSpec)
+      raise "has_#{transport_type}_pact_between has to be declared at the top level of a suite" unless top_level?
+      raise "has_*_pact_between cannot be declared more than once per suite" if defined?(@_pact_config)
+
+      # rubocop:disable RSpec/BeforeAfterAll
+      before(:context) do
+        @_pact_config = Pact::V2::Consumer::PactConfig.new(transport_type, consumer_name: consumer, provider_name: provider, opts: opts)
+      end
+      # rubocop:enable RSpec/BeforeAfterAll
+    end
+  end
+
+  def new_interaction(description = nil)
+    pact_config.new_interaction(description)
+  end
+
+  def reset_pact # rubocop:disable Rails/Delegate
+    pact_config.reset_pact
+  end
+
+  def pact_config
+    instance_variable_get(:@_pact_config)
+  end
+
+  def execute_http_pact
+    raise InteractionBuilderError.new("interaction is designed to be used one-time only") if defined?(@used)
+    mock_server = Pact::V2::Consumer::MockServer.create_for_http!(
+      pact: pact_config.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 Pact::V2::Consumer::HttpInteractionBuilder::InteractionMismatchesError.new(msg)
+    end
+    @used = true
+    mock_server&.cleanup
+    reset_pact
+  end
+
+
+  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
+end
+
+RSpec.configure do |config|
+  config.include PactV2ConsumerDsl, pact_entity: :consumer
+  config.extend PactV2ConsumerDsl::ClassMethods, pact_entity: :consumer
+end

data/lib/pact/v2/rspec/support/pact_message_helpers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "waterdrop/pact_waterdrop_client"
+
+module PactMessageHelpers
+  module ProviderHelpers
+    def with_pact_producer
+      client = PactWaterdropClient.new
+      yield(client)
+      client.to_pact
+    end
+
+    def produce_outbox_item(item)
+      raise "Please require sbmt/kafka_producer to use helper" unless defined?(::Sbmt::KafkaProducer)
+
+      with_pact_producer do |client|
+        Sbmt::KafkaProducer::OutboxProducer.new(
+          client: client, topic: item.transports.first.topic
+        ).call(item, item.payload)
+      end
+    end
+  end
+
+  module ConsumerHelpers
+    def outbox_headers
+      raise "Please require sbmt/outbox to use helper" unless defined?(::Sbmt::Outbox)
+
+      {
+        Sbmt::Outbox::OutboxItem::OUTBOX_HEADER_NAME => match_regex(/(.+?_)*outbox_item/, "order_outbox_item"),
+        Sbmt::Outbox::OutboxItem::IDEMPOTENCY_HEADER_NAME => match_uuid,
+        Sbmt::Outbox::OutboxItem::SEQUENCE_HEADER_NAME => match_regex(/\d+/, "68"),
+        Sbmt::Outbox::OutboxItem::EVENT_TIME_HEADER_NAME => match_iso8601,
+        Sbmt::Outbox::OutboxItem::DISPATCH_TIME_HEADER_NAME => match_iso8601
+      }
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.extend PactMessageHelpers::ProviderHelpers, pact_entity: :provider
+  config.include PactMessageHelpers::ConsumerHelpers, pact_entity: :consumer
+end

data/lib/pact/v2/rspec/support/pact_provider_helpers.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "pact_message_helpers"
+require_relative "webmock/webmock_helpers"
+
+module PactV2ProducerDsl
+  module ClassMethods
+    PACT_PROVIDER_NOT_DECLARED_MESSAGE = "http_pact_provider or grpc_pact_provider should be declared first"
+
+    def http_pact_provider(provider, opts: {})
+      _pact_provider(:http, provider, opts: opts)
+    end
+
+    def grpc_pact_provider(provider, opts: {})
+      _pact_provider(:grpc, provider, opts: opts)
+    end
+
+    def message_pact_provider(provider, opts: {})
+      _pact_provider(:async, provider, opts: opts)
+    end
+
+    def mixed_pact_provider(provider, opts: {})
+      execute_mixed_pact_provider(:mixed, provider, opts: opts)
+    end
+
+    def execute_mixed_pact_provider(transport_type, provider, opts: {})
+      raise "#{transport_type}_pact_provider is designed to be used with RSpec" unless defined?(::RSpec)
+      raise "#{transport_type}_pact_provider has to be declared at the top level of a suite" unless top_level?
+      raise "mixed_pact_provider is designed to be run once per provider so cannot be declared more than once" if defined?(@_pact_config)
+
+      pact_config_instance = Pact::V2::Provider::PactConfig.new(transport_type, provider_name: provider, opts: opts)
+      instance_variable_set(:@_pact_config, pact_config_instance)
+
+      # rubocop:disable RSpec/BeforeAfterAll
+      before(:context) do
+        # rspec allows only context ivars in specs and ignores the rest
+        # so we use block-as-a-closure feature to save pact_config ivar reference and make it available for descendants
+        @_pact_config = pact_config_instance
+      end
+      # rubocop:enable RSpec/BeforeAfterAll
+
+      it "verifies mixed interactions with provider #{provider}" do
+        pact_config.start_servers
+        # todo: call any available verifier, or exit if none specified
+        pact_config.http_config.new_verifier(@_pact_config).verify!
+      end
+    end
+
+    def _pact_provider(transport_type, provider, opts: {})
+      raise "#{transport_type}_pact_provider is designed to be used with RSpec" unless defined?(::RSpec)
+      raise "#{transport_type}_pact_provider has to be declared at the top level of a suite" unless top_level?
+      raise "*_pact_provider is designed to be run once per provider so cannot be declared more than once" if defined?(@_pact_config)
+
+      pact_config_instance = Pact::V2::Provider::PactConfig.new(transport_type, provider_name: provider, opts: opts)
+      instance_variable_set(:@_pact_config, pact_config_instance)
+
+      # rubocop:disable RSpec/BeforeAfterAll
+      before(:context) do
+        # rspec allows only context ivars in specs and ignores the rest
+        # so we use block-as-a-closure feature to save pact_config ivar reference and make it available for descendants
+        @_pact_config = pact_config_instance
+      end
+      # rubocop:enable RSpec/BeforeAfterAll
+
+      it "verifies interactions with provider #{provider}" do
+        pact_config.new_verifier.verify!
+      end
+    end
+
+    def before_state_setup(&block)
+      raise PACT_PROVIDER_NOT_DECLARED_MESSAGE unless pact_config
+      pact_config.before_setup(&block)
+    end
+
+    def after_state_teardown(&block)
+      raise PACT_PROVIDER_NOT_DECLARED_MESSAGE unless pact_config
+      pact_config.after_teardown(&block)
+    end
+
+    def provider_state(name, opts: {}, &block)
+      raise PACT_PROVIDER_NOT_DECLARED_MESSAGE unless pact_config
+      pact_config.new_provider_state(name, opts: opts, &block)
+    end
+
+    def handle_message(name, opts: {}, &block)
+      async_klass = Pact::V2::Provider::PactConfig::Async
+      if defined?(@_pact_config) &&
+          @_pact_config.respond_to?(:async_config) &&
+          @_pact_config.async_config.is_a?(async_klass)
+        @_pact_config.async_config.new_message_handler(name, opts: opts, &block)
+      elsif pact_config &&
+          pact_config.respond_to?(:async_config) &&
+          pact_config.async_config.is_a?(async_klass)
+        pact_config.async_config.new_message_handler(name, opts: opts, &block)
+      elsif defined?(@_pact_config) &&
+          @_pact_config.is_a?(async_klass)
+        @_pact_config.new_message_handler(name, opts: opts, &block)
+      elsif pact_config.is_a?(async_klass)
+        pact_config.new_message_handler(name, opts: opts, &block)
+
+      else
+        raise "handle_message can only be used with message_pact_provider or mixed_pact_provider with an async block"
+      end
+    end
+
+    def pact_config
+      instance_variable_get(:@_pact_config)
+    end
+  end
+
+  def pact_config
+    instance_variable_get(:@_pact_config)
+  end
+end
+
+RSpec.configure do |config|
+  config.include PactV2ProducerDsl, pact_entity: :provider
+  config.extend PactV2ProducerDsl::ClassMethods, pact_entity: :provider
+
+  config.around pact_entity: :provider do |example|
+    WebmockHelpers.turned_off do
+      if defined?(::VCR)
+        VCR.turned_off { example.run }
+      else
+        example.run
+      end
+    end
+  end
+end

data/lib/pact/v2/rspec/support/waterdrop/pact_waterdrop_client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class PactWaterdropClient
+  attr_reader :message
+
+  Report = Struct.new(:partition, :offset, :topic_name, keyword_init: true)
+
+  def produce_async(message)
+    @message = message
+  end
+
+  def produce_sync(message)
+    @message = message
+    Report.new(partition: 0, offset: 0, topic_name: message[:topic])
+  end
+
+  def to_pact(content_type: nil)
+    payload = message[:payload]
+    metadata = {
+      key: message[:key],
+      topic: message[:topic],
+      content_type: content_type
+    }.merge(message[:headers] || {})
+
+    [payload, metadata]
+  end
+end

data/lib/pact/v2/rspec/support/webmock/webmock_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module WebmockHelpers
+  def self.turned_off
+    yield unless defined?(::WebMock)
+
+    allow_net_connect = WebMock::Config.instance.allow_net_connect
+    allow_localhost = WebMock::Config.instance.allow_localhost
+    allow_hosts = WebMock::Config.instance.allow
+    net_http_connect_on_start = WebMock::Config.instance.net_http_connect_on_start
+
+    return yield if allow_net_connect
+
+    WebMock.allow_net_connect!
+
+    result = yield
+
+    # disable_net_connect! resets previous config settings
+    # so we need to specify them explicitly
+    WebMock.disable_net_connect!(
+      {
+        allow_localhost: allow_localhost,
+        allow: allow_hosts,
+        net_http_connect_on_start: net_http_connect_on_start
+      }
+    )
+
+    result
+  end
+end

data/lib/pact/v2/rspec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rspec"
+require_relative "rspec/support/pact_consumer_helpers"
+require_relative "rspec/support/pact_provider_helpers"
+
+RSpec.configure do |config|
+  config.define_derived_metadata(file_path: %r{spec/pact/}) { |metadata| metadata[:pact] = true }
+
+  # it's not an error: consumer tests contain `providers` subdirectory (because we're testing against different providers)
+  config.define_derived_metadata(file_path: %r{spec/pact/providers/}) { |metadata| metadata[:pact_entity] = :consumer }
+  # for provider tests it's the same thing: we're running tests which test consumers
+  config.define_derived_metadata(file_path: %r{spec/pact/consumers/}) { |metadata| metadata[:pact_entity] = :provider }
+
+  # exclude pact specs from generic rspec pipeline
+  config.filter_run_excluding :pact_v2
+end

data/lib/pact/v2/tasks/pact.rake

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:pact_v2).tap do |task|
+  task.pattern = "spec/pact/consumers/**/*_spec.rb"
+  task.rspec_opts = "--require rails_helper_v2 --tag pact_v2"
+end
+
+namespace :pact_v2 do
+  desc "Verifies the pact files"
+  task verify: :pact_v2
+end

data/lib/pact/v2.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "pact/ffi"
+
+require "pact/v2/railtie" if defined?(Rails::Railtie)
+
+module Pact
+  module V2
+    class Error < StandardError; end
+
+    class ImplementationRequired < Error; end
+
+    class FfiError < Error
+      def initialize(msg, reason, status)
+        super(msg)
+
+        @msg = msg
+        @reason = reason
+        @status = status
+      end
+
+      def message
+        "FFI error: reason: #{@reason}, status: #{@status}, message: #{@msg}"
+      end
+    end
+
+    def self.configure
+      yield configuration if block_given?
+    end
+
+    def self.configuration
+      @configuration ||= Pact::V2::Configuration.new
+    end
+  end
+end
+
+loader = Zeitwerk::Loader.new
+loader.push_dir(File.join(__dir__, ".."))
+
+loader.tag = "pact-v2"
+
+# existing pact-ruby ignores
+# loader.ignore("#{__dir__}/../pact") # ignore the pact dir at the root of the repo
+# loader.ignore("#{__dir__}/../pact/v2",false) # ignore the pact dir at the root of the repo
+# loader.push_dir(File.join(__dir__))
+
+
+loader.ignore("#{__dir__}/../pact/version.rb")
+loader.ignore("#{__dir__}/../pact/cli")
+loader.ignore("#{__dir__}/../pact/cli.rb")
+loader.ignore("#{__dir__}/../pact/consumer")
+loader.ignore("#{__dir__}/../pact/consumer.rb")
+loader.ignore("#{__dir__}/../pact/doc")
+loader.ignore("#{__dir__}/../pact/hal")
+loader.ignore("#{__dir__}/../pact/hash_refinements.rb")
+loader.ignore("#{__dir__}/../pact/pact_broker")
+loader.ignore("#{__dir__}/../pact/pact_broker.rb")
+loader.ignore("#{__dir__}/../pact/project_root.rb")
+loader.ignore("#{__dir__}/../pact/provider")
+loader.ignore("#{__dir__}/../pact/provider.rb")
+loader.ignore("#{__dir__}/../pact/retry.rb")
+loader.ignore("#{__dir__}/../pact/tasks")
+loader.ignore("#{__dir__}/../pact/tasks.rb")
+loader.ignore("#{__dir__}/../pact/templates")
+loader.ignore("#{__dir__}/../pact/utils")
+loader.ignore("#{__dir__}/../pact/v2/rspec.rb")
+loader.ignore("#{__dir__}/../pact/v2/rspec")
+loader.ignore("#{__dir__}/../pact/v2/railtie.rb") unless defined?(Rails::Railtie)
+loader.setup
+loader.eager_load