pact 1.67.5 → 2.0.1

data/lib/pact/provider/grpc_verifier.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'pact/ffi/verifier'
+require 'pact/native/logger'
+
+module Pact
+  module Provider
+    class GrpcVerifier < BaseVerifier
+      PROVIDER_TRANSPORT_TYPE = 'grpc'
+
+      def initialize(pact_config, mixed_config = nil)
+        super
+
+        unless pact_config.is_a?(::Pact::Provider::PactConfig::Grpc)
+          raise ArgumentError,
+                'pact_config must be an instance of Pact::Provider::PactConfig::Grpc'
+        end
+
+        @grpc_server = GrufServer.new(host: "127.0.0.1:#{@pact_config.grpc_port}",
+                                      services: @pact_config.grpc_services, logger: @pact_config.logger)
+      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

data/lib/pact/provider/gruf_server.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pact
+  module Provider
+    # inspired by Gruf::Cli::Executor
+    class GrufServer
+      SERVER_STOP_TIMEOUT_SEC = 15
+
+      def initialize(options = {})
+        @options = options
+
+        setup!
+
+        @server_pid = nil
+
+        @services = @options[:services].is_a?(Array) ? @options[:services] : []
+        @logger = @options[:logger] || ::Logger.new($stdout)
+      end
+
+      def start
+        raise "server already running, stop server before starting new one" if @thread
+
+        @logger.info("[gruf] starting standalone server with options: #{@options}")
+
+        @server = Gruf::Server.new(Gruf.server_options)
+        @services.each { |s| @server.add_service(s) } if @services.any?
+        @thread = Thread.new do
+          @logger.debug "[gruf] starting grpc server"
+          @server.start!
+        end
+        @server.server.wait_till_running(10)
+
+        @logger.info("[gruf] standalone server started")
+      end
+
+      def stop
+        @logger.info("[gruf] stopping standalone server")
+
+        @server&.server&.stop
+        @thread&.join(SERVER_STOP_TIMEOUT_SEC)
+        @thread&.kill
+
+        @logger.info("[gruf] standalone server stopped")
+      end
+
+      ##
+      # Run the server
+      #
+      def run
+        start
+
+        yield
+      rescue => e
+        @logger.fatal("FATAL ERROR: #{e.message} #{e.backtrace.join("\n")}")
+        raise
+      ensure
+        stop
+      end
+
+      private
+
+      def setup!
+        Gruf.server_binding_url = @options[:host] if @options[:host]
+        if @options[:suppress_default_interceptors]
+          Gruf.interceptors.remove(Gruf::Interceptors::ActiveRecord::ConnectionReset)
+          Gruf.interceptors.remove(Gruf::Interceptors::Instrumentation::OutputMetadataTimer)
+        end
+        Gruf.backtrace_on_error = true if @options[:backtrace_on_error]
+        Gruf.health_check_enabled = true if @options[:health_check]
+      end
+    end
+  end
+end

data/lib/pact/provider/http_server.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Pact
+  module Provider
+    # inspired by Gruf::Cli::Executor
+    class HttpServer
+      SERVER_STOP_TIMEOUT_SEC = 15
+
+      def initialize(options = {})
+        @options = options
+
+        @server_pid = nil
+
+        @host = @options[:host] || "localhost"
+        @logger = @options[:logger] || ::Logger.new($stdout)
+        # allow any rack based app to be passed in, otherwise
+        # we will load a Rails.application
+        # allows for backwards compat with pact-ruby v1
+        @app = @options[:app] || nil
+      end
+
+      def start
+        raise "server already running, stop server before starting new one" if @thread
+
+        @logger.info("[webrick] starting server with options: #{@options}")
+
+        @thread = Thread.new do
+          @logger.debug "[webrick] starting http server"
+
+          # TODO: load from config.ru, if not rails and no app provided?
+          # 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
+          handler.run(@app || (defined?(Rails) ? Rails.application : nil),
+            Host: @options[:host],
+            Port: @options[:port],
+            Logger: @logger,
+            StartCallback: -> { @started = true }) do |server|
+            @server = server
+          end
+        end
+        sleep 0.001 until @started
+
+        @logger.info("[webrick] server started")
+      end
+
+      def stop
+        @logger.info("[webrick] stopping server")
+
+        @server&.shutdown
+        @thread&.join(SERVER_STOP_TIMEOUT_SEC)
+        @thread&.kill
+
+        @logger.info("[webrick] server stopped")
+      end
+
+      ##
+      # Run the server
+      #
+      def run
+        start
+
+        yield
+      rescue => e
+        @logger.fatal("FATAL ERROR: #{e.message} #{e.backtrace.join("\n")}")
+        raise
+      ensure
+        stop
+      end
+    end
+  end
+end

data/lib/pact/provider/http_verifier.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'pact/ffi/verifier'
+require 'pact/native/logger'
+
+module Pact
+  module Provider
+    class HttpVerifier < BaseVerifier
+      PROVIDER_TRANSPORT_TYPE = 'http'
+
+      def initialize(pact_config, mixed_config = nil)
+        super
+
+        unless pact_config.is_a?(::Pact::Provider::PactConfig::Http)
+          raise ArgumentError,
+                'pact_config must be an instance of Pact::Provider::PactConfig::Http'
+        end
+
+        @http_server = HttpServer.new(host: '127.0.0.1', port: @pact_config.http_port, app: @pact_config.app,
+                                      logger: @pact_config.logger)
+      end
+
+      private
+
+      def set_provider_info(pact_handle)
+        PactFfi::Verifier.set_provider_info(pact_handle, @pact_config.provider_name, '', '', @pact_config.http_port, '')
+      end
+
+      def add_provider_transport(pact_handle)
+        # The http transport is already added when the `set_provider_info` method is called,
+        # so we don't need to explicitly add the transport here
+      end
+
+      def start_servers!
+        super
+        @http_server.start
+      end
+
+      def stop_servers
+        super
+        @http_server.stop
+      end
+    end
+  end
+end

data/lib/pact/provider/message_provider_servlet.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  module Provider
+    class MessageProviderServlet < WEBrick::HTTPServlet::ProcHandler
+      attr_reader :logger
+
+      CONTENT_TYPE_JSON = "application/json"
+      CONTENT_TYPE_PROTO = "application/protobuf"
+      METADATA_HEADER = "pact-message-metadata"
+
+      def initialize(logger: nil)
+        super(build_proc)
+
+        @message_handlers = {}
+
+        @logger = logger || Logger.new($stdout)
+      end
+
+      def add_message_handler(name, &block)
+        raise "message handler for #{name} already configured" if @message_handlers[name].present?
+
+        @message_handlers[name] = {proc: block}
+      end
+
+      private
+
+      def build_proc
+        proc do |request, response|
+          # {"description":"message: ","providerStates":[{"name":"pet exists","params":{"pet_id":1}}]}
+          data = JSON.parse(request.body)
+
+          description = data["description"]
+          provider_states = data["providerStates"]
+
+          body, metadata = handle(description, provider_states)
+
+          response.status = 200
+          if body.is_a?(String)
+            # protobuf-serialized body
+            response.body = body
+            response.content_type = metadata[:content_type] || CONTENT_TYPE_PROTO
+          else
+            response.body = body.to_json
+            response.content_type = CONTENT_TYPE_JSON
+          end
+          response[METADATA_HEADER] = Base64.urlsafe_encode64(metadata.to_json)
+        rescue JSON::ParserError => ex
+          logger.error("cannot parse request: #{ex.message}")
+          response.status = 500
+        rescue => ex
+          logger.error("cannot handle message request: #{ex.message}")
+          response.status = 500
+        end
+      end
+
+      def handle(description, provider_states)
+        handler = find_handler_for(description)
+        return {}, {} unless handler
+
+        body, metadata = handler[:proc].call(provider_states&.first || {})
+        unless metadata[:content_type]
+          # try to find content-type in provider states
+          content_type = provider_states&.filter_map { |state| state.dig("params", "contentType") }&.first
+          metadata[:content_type] = content_type if content_type
+        end
+        [body, metadata]
+      end
+
+      def find_handler_for(description)
+        @message_handlers[description]
+      end
+    end
+  end
+end

data/lib/pact/provider/mixed_verifier.rb

@@ -0,0 +1,21 @@
+# # frozen_string_literal: true
+module Pact
+  module Provider
+    # MixedVerifier coordinates verification for all present configs (async, grpc, http)
+    class MixedVerifier
+      attr_reader :mixed_config, :verifiers
+
+      def initialize(mixed_config)
+        unless mixed_config.is_a?(::Pact::Provider::PactConfig::Mixed)
+          raise ArgumentError, 'mixed_config must be a PactConfig::Mixed'
+        end
+
+        @mixed_config = mixed_config
+        @verifiers = []
+        @verifiers << AsyncMessageVerifier.new(mixed_config.async_config) if mixed_config.async_config
+        @verifiers << GrpcVerifier.new(mixed_config.grpc_config) if mixed_config.grpc_config
+        @verifiers << HttpVerifier.new(mixed_config.http_config) if mixed_config.http_config
+      end
+    end
+  end
+end

data/lib/pact/provider/pact_broker_proxy.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rack-proxy'
+
+module Pact
+  module Provider
+    class PactBrokerProxy < Rack::Proxy
+      attr_reader :backend_uri, :path, :logger
+
+      # e.g. /pacts/provider/paas-stand-seeker/consumer/paas-stand-placer/pact-version/2967a9343bd8fdd28a286c4b8322380020618892/metadata/c1tdW2VdPXByb2R1Y3Rpb24mc1tdW2N2XT03MzIy # rubocop:disable Layout/LineLength
+      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
+        @logger = opts[:logger] || Logger.new($stdout)
+      end
+
+      def perform_request(env)
+        request = Rack::Request.new(env)
+        env['rack.timeout'] ||= ENV.fetch('PACT_BROKER_REQUEST_TIMEOUT', 5).to_i
+        @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?
+
+        JSON.generate(parsed_body)
+      rescue JSON::ParserError => e
+        logger.error("cannot parse broker response: #{e.message}")
+      end
+    end
+  end
+end

data/lib/pact/provider/pact_broker_proxy_runner.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  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, Logger: @logger, AccessLog: [] },
+          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

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pact
+  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
+

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+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_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, :logger
+
+
+        def initialize(provider_name:, opts: {})
+          @provider_name = provider_name
+          @log_level = opts[:log_level] || :info
+          @pact_dir = opts[:pact_dir] || nil
+          @logger = opts[:logger] || nil
+          @provider_setup_port = opts[:provider_setup_port] || 9001
+          @pact_proxy_port = opts[:pact_proxy_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, logger: @logger)
+          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,
+              logger: @logger
+            )
+          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 PactImplementationRequired, "#new_verifier should be implemented"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+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] || 0
+          @grpc_services = opts[:grpc_services] || []
+        end
+
+        def new_verifier(config = nil)
+          GrpcVerifier.new(self, config)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Pact
+  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