sbmt-pact 0.12.0

data/lib/sbmt/pact/provider/pact_broker_proxy.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "rack-proxy"
+
+module Sbmt
+  module Pact
+    module Provider
+      class PactBrokerProxy < Rack::Proxy
+        attr_reader :backend_uri, :path, :filter_type, :logger
+
+        # e.g. /pacts/provider/paas-stand-seeker/consumer/paas-stand-placer/pact-version/2967a9343bd8fdd28a286c4b8322380020618892/metadata/c1tdW2VdPXByb2R1Y3Rpb24mc1tdW2N2XT03MzIy
+        PACT_FILE_REQUEST_PATH_REGEX = %r{/pacts/provider/.+?/consumer/.+?/pact-version/.+}.freeze
+
+        def initialize(app = nil, opts = {})
+          super
+          @backend_uri = URI(opts[:backend])
+          @path = nil
+          @filter_type = opts[:filter_type]
+          @logger = opts[:logger] || Logger.new($stdout)
+        end
+
+        def perform_request(env)
+          request = Rack::Request.new(env)
+          @path = request.path
+
+          super
+        end
+
+        def rewrite_env(env)
+          env["HTTP_HOST"] = backend_uri.host
+          env
+        end
+
+        def rewrite_response(triplet)
+          status, headers, body = triplet
+
+          if status == "200" && PACT_FILE_REQUEST_PATH_REGEX.match?(path)
+            patched_body = patch_response(body.first)
+
+            # we need to recalculate content length
+            headers[Rack::CONTENT_LENGTH] = patched_body.bytesize.to_s
+
+            return [status, headers, [patched_body]]
+          end
+
+          triplet
+        end
+
+        private
+
+        def patch_response(raw_body)
+          parsed_body = JSON.parse(raw_body)
+
+          return body if parsed_body["consumer"].blank? || parsed_body["provider"].blank?
+          return body if parsed_body["interactions"].blank?
+
+          filter_interactions(parsed_body)
+
+          JSON.generate(parsed_body)
+        rescue JSON::ParserError => ex
+          logger.error("cannot parse broker response: #{ex.message}")
+        end
+
+        def filter_interactions(pact_json_hash)
+          return pact_json_hash unless filter_type
+
+          pact_json_hash["interactions"].each do |interaction|
+            set_description_prefix(interaction, "grpc:") if interaction["transport"] == "grpc" && filter_type == :grpc
+            set_description_prefix(interaction, "http:") if interaction["transport"] == "http" && filter_type == :http
+            set_description_prefix(interaction, "http:") if interaction["type"] == "Synchronous/HTTP" && filter_type == :http
+            set_description_prefix(interaction, "async:") if interaction["type"] == "Asynchronous/Messages" && filter_type == :async
+            set_description_prefix(interaction, "sync:") if interaction["type"] == "Synchronous/Messages" && filter_type == :sync
+          end
+
+          pact_json_hash
+        end
+
+        def set_description_prefix(interaction, prefix)
+          orig_description = interaction["description"]
+          interaction["description"] = "#{prefix} #{orig_description}" unless orig_description.start_with?(prefix)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Sbmt
+  module Pact
+    module Provider
+      class PactBrokerProxyRunner
+        attr_reader :logger
+
+        FILTER_TYPE_NONE = nil
+        FILTER_TYPE_GRPC = :grpc
+        FILTER_TYPE_ASYNC = :async
+        FILTER_TYPE_SYNC = :sync
+        FILTER_TYPE_HTTP = :http
+
+        def initialize(pact_broker_host:, filter_type: nil, port: 9002, host: "127.0.0.1", pact_broker_user: nil, pact_broker_password: nil, logger: nil)
+          @host = host
+          @port = port
+          @pact_broker_host = pact_broker_host
+          @filter_type = filter_type
+          @pact_broker_user = pact_broker_user
+          @pact_broker_password = pact_broker_password
+          @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
+
+          @server = WEBrick::HTTPServer.new({BindAddress: @host, Port: @port}, WEBrick::Config::HTTP)
+          @server.mount("/", Rack::Handler::WEBrick, PactBrokerProxy.new(
+            nil,
+            backend: @pact_broker_host, streaming: false, filter_type: @filter_type,
+            username: @pact_broker_user, password: @pact_broker_password, logger: @logger
+          ))
+
+          @thread = Thread.new do
+            Rails.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/sbmt/pact/provider/pact_config/async.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Sbmt
+  module Pact
+    module Provider
+      module PactConfig
+        class Async < Base
+          def new_message_handler(name, opts: {}, &block)
+            provider_setup_server.add_message_handler(name, &block)
+          end
+
+          def filter_type
+            PACT_BROKER_FILTER_TYPE_ASYNC
+          end
+
+          def new_verifier
+            AsyncMessageVerifier.new(self)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    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_BROKER_FILTER_TYPE_NONE = PactBrokerProxyRunner::FILTER_TYPE_NONE
+          PACT_BROKER_FILTER_TYPE_GRPC = PactBrokerProxyRunner::FILTER_TYPE_GRPC
+          PACT_BROKER_FILTER_TYPE_ASYNC = PactBrokerProxyRunner::FILTER_TYPE_ASYNC
+          PACT_BROKER_FILTER_TYPE_SYNC = PactBrokerProxyRunner::FILTER_TYPE_SYNC
+          PACT_BROKER_FILTER_TYPE_HTTP = PactBrokerProxyRunner::FILTER_TYPE_HTTP
+
+          def initialize(provider_name:, opts: {})
+            @provider_name = provider_name
+            @log_level = opts[:log_level] || :info
+            @provider_setup_port = opts[:provider_setup_port] || 9001
+            @pact_proxy_port = opts[:provider_setup_port] || 9002
+            @provider_version = opts[:provider_version] || ENV.fetch("PACT_PROVIDER_VERSION", "1.0.0")
+            @consumer_branch = opts[:consumer_branch] || ENV.fetch("PACT_CONSUMER_BRANCH", nil)
+            @consumer_version = opts[:consumer_version] || ENV.fetch("PACT_CONSUMER_VERSION", nil)
+            @consumer_name = opts[:consumer_name]
+            @broker_url = opts[:broker_url] || ENV.fetch("PACT_BROKER_URL", nil)
+            @broker_username = opts[:broker_username] || ENV.fetch("PACT_BROKER_USERNAME", "")
+            @broker_password = opts[:broker_password] || ENV.fetch("PACT_BROKER_PASSWORD", "")
+            @verify_only = opts[:verify_only] || [ENV.fetch("PACT_CONSUMER_FULL_NAME", nil)].compact
+
+            @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, filter_type: filter_type,
+                pact_broker_user: @broker_username, pact_broker_password: @broker_password
+              )
+            end
+          end
+
+          def filter_type
+            PACT_BROKER_FILTER_TYPE_NONE
+          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
+            @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 Sbmt::Pact::ImplementationRequired, "#new_verifier should be implemented"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Sbmt
+  module Pact
+    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] || 3009
+            @grpc_services = opts[:grpc_services] || []
+          end
+
+          def filter_type
+            PACT_BROKER_FILTER_TYPE_GRPC
+          end
+
+          def new_verifier
+            GrpcVerifier.new(self)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "pact_config/grpc"
+
+module Sbmt
+  module Pact
+    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)
+          else
+            raise ArgumentError, "unknown transport_type: #{transport_type}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Sbmt
+  module Pact
+    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
+            Rails.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/sbmt/pact/provider/provider_state_configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sbmt
+  module Pact
+    module Provider
+      class ProviderStateConfiguration
+        attr_reader :name, :opts, :setup_proc, :teardown_proc
+
+        class ProviderStateConfigurationError < ::Sbmt::Pact::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/sbmt/pact/provider/provider_state_servlet.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Sbmt
+  module Pact
+    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 = ::Sbmt::Pact.configuration.before_provider_state_proc
+          @global_teardown_hook = ::Sbmt::Pact.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)
+          @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)
+          @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/sbmt/pact/provider.rb

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

data/lib/sbmt/pact/railtie.rb

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

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "pact_message_helpers"
+
+module SbmtPactConsumerDsl
+  include Sbmt::Pact::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 = Sbmt::Pact::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 pact_config
+    instance_variable_get(:@_pact_config)
+  end
+end
+
+RSpec.configure do |config|
+  config.include SbmtPactConsumerDsl, pact_entity: :consumer
+  config.extend SbmtPactConsumerDsl::ClassMethods, pact_entity: :consumer
+end

data/lib/sbmt/pact/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