pact 1.67.5 → 2.0.0

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

@@ -1,75 +0,0 @@
-# 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

@@ -1,79 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-# 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, 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
-end

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

@@ -1,79 +0,0 @@
-# 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: 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
-end

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

@@ -1,22 +0,0 @@
-# # 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

@@ -1,66 +0,0 @@
-# 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

@@ -1,80 +0,0 @@
-# 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, 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
-end

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

@@ -1,29 +0,0 @@
-# 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

@@ -1,103 +0,0 @@
-# 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, :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 Pact::V2::ImplementationRequired, "#new_verifier should be implemented"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# # 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, 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
-            @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