pact 1.66.1 → 1.67.0

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    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
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    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
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "pact/v2/native/logger"
+
+module Pact
+  module V2
+    module Provider
+      class HttpVerifier < BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = "http"
+
+        def initialize(pact_config, mixed_config = nil)
+          super
+
+          raise ArgumentError, "pact_config must be an instance of Pact::V2::Provider::PactConfig::Http" unless pact_config.is_a?(::Pact::V2::Provider::PactConfig::Http)
+          @http_server = HttpServer.new(host: "127.0.0.1", port: @pact_config.http_port, app: @pact_config.app)
+        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
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "webrick"
+
+module Pact
+  module V2
+    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: Logger.new($stdout))
+          super(build_proc)
+
+          @message_handlers = {}
+
+          @logger = logger
+        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
+end

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

@@ -0,0 +1,22 @@
+# # frozen_string_literal: true
+module Pact
+  module V2
+    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::V2::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
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rack-proxy"
+
+module Pact
+  module V2
+    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
+        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 => ex
+          logger.error("cannot parse broker response: #{ex.message}")
+        end
+
+      end
+    end
+  end
+end

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