pact-v2 2.0.0.pre.preview1

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  module V2
+    module Provider
+      class PactBrokerProxyRunner
+        attr_reader :logger
+
+
+        def initialize(pact_broker_host:, port: 9002, host: "127.0.0.1", pact_broker_user: nil, pact_broker_password: nil, pact_broker_token: nil, logger: nil)
+          @host = host
+          @port = port
+          @pact_broker_host = pact_broker_host
+          @pact_broker_user = pact_broker_user
+          @pact_broker_password = pact_broker_password
+          @pact_broker_token = pact_broker_token
+          @logger = logger || Logger.new($stdout)
+
+          @thread = nil
+        end
+
+        def proxy_url
+          "http://#{@host}:#{@port}"
+        end
+
+        def start
+          raise "server already running, stop server before starting new one" if @thread
+            # Rack 2/3 compatibility
+          begin
+            require 'rack/handler/webrick'
+            handler = ::Rack::Handler::WEBrick
+          rescue LoadError
+            require 'rackup/handler/webrick'
+            handler = Class.new(Rackup::Handler::WEBrick)
+          end
+          @server = WEBrick::HTTPServer.new({BindAddress: @host, Port: @port}, WEBrick::Config::HTTP)
+          @server.mount("/", handler, PactBrokerProxy.new(
+            nil,
+            backend: @pact_broker_host,
+            streaming: false,
+            username: @pact_broker_user || nil,
+            password: @pact_broker_password || nil,
+            token: @pact_broker_token || nil,
+            logger: @logger
+          ))
+
+          @thread = Thread.new do
+            @logger.debug "starting pact broker proxy server"
+            @server.start
+          end
+        end
+
+        def stop
+          @logger.info("stopping pact broker proxy server")
+
+          @server&.shutdown
+          @thread&.join
+
+          @logger.info("pact broker proxy server stopped")
+        end
+
+        def run
+          start
+
+          yield
+        rescue => e
+          logger.fatal("FATAL ERROR: #{e.message} #{e.backtrace.join("\n")}")
+          raise
+        ensure
+          stop
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pact
+  module V2
+    module Provider
+      module PactConfig
+        class Async < Base
+          def initialize(provider_name:, opts: {})
+            super
+            handlers = opts[:message_handlers] || {}
+            handlers.each do |name, block|
+              new_message_handler(name, &block)
+            end
+          end
+
+          def new_message_handler(name, opts: {}, &block)
+            provider_setup_server.add_message_handler(name, &block)
+          end
+
+          def new_verifier(config = nil)
+            AsyncMessageVerifier.new(self, config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Provider
+      module PactConfig
+        class Base
+          attr_reader :provider_name, :provider_version, :log_level, :provider_setup_server, :provider_setup_port, :pact_proxy_port,
+            :consumer_branch, :consumer_version, :consumer_name, :broker_url, :broker_username, :broker_password, :verify_only, :pact_dir,
+            :pact_uri, :provider_version_branch, :provider_version_tags, :consumer_version_selectors, :enable_pending, :include_wip_pacts_since,
+            :fail_if_no_pacts_found, :provider_build_uri, :broker_token, :consumer_version_tags, :publish_verification_results
+
+
+          def initialize(provider_name:, opts: {})
+            @provider_name = provider_name
+            @log_level = opts[:log_level] || :info
+            @pact_dir = opts[:pact_dir] || nil
+            @provider_setup_port = opts[:provider_setup_port] || 9001
+            @pact_proxy_port = opts[:provider_setup_port] || 9002
+            @pact_uri = ENV.fetch("PACT_URL", nil) || opts.fetch(:pact_uri, nil)
+            @publish_verification_results = ENV.fetch("PACT_PUBLISH_VERIFICATION_RESULTS", nil) == "true" || opts.fetch(:publish_verification_results, false)
+            @provider_version = ENV.fetch("PACT_PROVIDER_VERSION", nil) || opts.fetch(:provider_version, nil)
+            @provider_build_uri = ENV.fetch("PACT_PROVIDER_BUILD_URL", nil) || opts.fetch(:provider_build_uri, nil)
+            @provider_version_branch = ENV.fetch("PACT_PROVIDER_BRANCH", nil) || opts.fetch(:provider_version_branch, nil)
+            @provider_version_tags = ENV.fetch("PACT_PROVIDER_VERSION_TAGS", nil) || opts.fetch(:provider_version_tags, [])
+            @consumer_version_tags = ENV.fetch("PACT_CONSUMER_VERSION_TAGS", nil) || opts.fetch(:consumer_version_tags, [])
+            @consumer_version_selectors = ENV.fetch("PACT_CONSUMER_VERSION_SELECTORS", nil) || opts.fetch(:consumer_version_selectors, nil)
+            @enable_pending = ENV.fetch("PACT_VERIFIER_ENABLE_PENDING", nil) == "true" || opts.fetch(:enable_pending, false)
+            @include_wip_pacts_since = ENV.fetch("PACT_INCLUDE_WIP_PACTS_SINCE", nil) || opts.fetch(:include_wip_pacts_since, nil)
+            @fail_if_no_pacts_found = ENV.fetch("PACT_FAIL_IF_NO_PACTS_FOUND", nil) == "true" || opts.fetch(:fail_if_no_pacts_found, true)
+            @consumer_branch = ENV.fetch("PACT_CONSUMER_BRANCH", nil) || opts.fetch(:consumer_branch, nil)
+            @consumer_version = ENV.fetch("PACT_CONSUMER_VERSION", nil) || opts.fetch(:consumer_version, nil)
+            @consumer_name = opts[:consumer_name]
+            @broker_url = ENV.fetch("PACT_BROKER_BASE_URL", nil) || opts.fetch(:broker_url, nil)
+            @broker_username = ENV.fetch("PACT_BROKER_USERNAME", nil) || opts.fetch(:broker_username, nil)
+            @broker_password = ENV.fetch("PACT_BROKER_PASSWORD", nil) || opts.fetch(:broker_password, nil)
+            @broker_token = ENV.fetch("PACT_BROKER_TOKEN", nil) || opts.fetch(:broker_token, nil)
+            @verify_only = [ENV.fetch("PACT_CONSUMER_FULL_NAME", nil)].compact || opts.fetch(:verify_only, [])
+
+            @provider_setup_server = opts[:provider_setup_server] || ProviderServerRunner.new(port: @provider_setup_port)
+            if @broker_url.present?
+              @pact_proxy_server = PactBrokerProxyRunner.new(
+                port: @pact_proxy_port,
+                pact_broker_host: @broker_url,
+                pact_broker_user: @broker_username,
+                pact_broker_password: @broker_password,
+                pact_broker_token: @broker_token
+              )
+            end
+          end
+
+
+          def start_servers
+            @provider_setup_server.start
+            @pact_proxy_server&.start
+          end
+
+          def stop_servers
+            @provider_setup_server.stop
+            @pact_proxy_server&.stop
+          end
+
+          def provider_setup_url
+            @provider_setup_server.state_setup_url
+          end
+
+          def message_setup_url # rubocop:disable Rails/Delegate
+            @provider_setup_server.message_setup_url
+          end
+
+          def pact_broker_proxy_url
+            @pact_proxy_server&.proxy_url
+          end
+
+          def new_provider_state(name, opts: {}, &block)
+            config = ProviderStateConfiguration.new(name, opts: opts)
+            config.instance_eval(&block)
+            config.validate!
+
+            use_hooks = !opts[:skip_hooks]
+
+            @provider_setup_server.add_setup_state(name, use_hooks, &config.setup_proc) if config.setup_proc
+            @provider_setup_server.add_teardown_state(name, use_hooks, &config.teardown_proc) if config.teardown_proc
+          end
+
+          def before_setup(&block)
+            @provider_setup_server.set_before_setup_hook(&block)
+          end
+
+          def after_teardown(&block)
+            @provider_setup_server.set_after_teardown_hook(&block)
+          end
+
+          def new_verifier
+            raise Pact::V2::ImplementationRequired, "#new_verifier should be implemented"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pact
+  module V2
+    module Provider
+      module PactConfig
+        class Grpc < Base
+          attr_reader :grpc_port, :grpc_services, :grpc_server
+
+          def initialize(provider_name:, opts: {})
+            super
+
+            @grpc_port = opts[:grpc_port] || 0
+            @grpc_services = opts[:grpc_services] || []
+          end
+
+          def new_verifier(config = nil)
+            GrpcVerifier.new(self, config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pact
+  module V2
+    module Provider
+      module PactConfig
+        class Http < Base
+          attr_reader :http_port
+          attr_reader :app
+
+          def initialize(provider_name:, opts: {})
+            super
+
+            @http_port = opts[:http_port] || 0
+            @app = opts[:app] || nil
+          end
+
+          def new_verifier(config = nil)
+            HttpVerifier.new(self, config)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# # frozen_string_literal: true
+
+module Pact
+  module V2
+    module Provider
+      module PactConfig
+        # Mixed config allows composing one of each: async, grpc, http
+        class Mixed < Base
+          attr_reader :async_config, :grpc_config, :http_config
+
+          def initialize(provider_name:, opts: {})
+            super
+            @provider_setup_server = ProviderServerRunner.new(port: @provider_setup_port)
+            if @broker_url.present?
+              @pact_proxy_server = PactBrokerProxyRunner.new(
+                port: @pact_proxy_port,
+                pact_broker_host: @broker_url,
+                pact_broker_user: @broker_username,
+                pact_broker_password: @broker_password,
+                pact_broker_token: @broker_token
+              )
+            end
+            @http_config = opts[:http] ? Http.new(provider_name: provider_name, opts: opts[:http].merge(provider_setup_server: provider_setup_server, pact_proxy_server: @pact_proxy_server)) : nil
+            @grpc_config = opts[:grpc] ? Grpc.new(provider_name: provider_name, opts: opts[:grpc].merge(provider_setup_server: provider_setup_server, pact_proxy_server: @pact_proxy_server)) : nil
+            @async_config = opts[:async] ? Async.new(provider_name: provider_name, opts: opts[:async].merge(provider_setup_server: provider_setup_server, pact_proxy_server: @pact_proxy_server)) : nil
+          end
+
+          def configs
+            [@async_config, @grpc_config, @http_config].compact
+          end
+
+          def start_servers
+          end
+
+        end
+      end
+    end
+  end
+end

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,80 @@
+# frozen_string_literal: true
+
+require_relative "pact_message_helpers"
+require "json"
+
+module PactV2ConsumerDsl
+  include Pact::V2::Matchers
+
+  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_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)
+
+    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
+  ensure
+    @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