hs-pact-mock_service 3.9.2

data/lib/pact/mock_service/request_handlers/options.rb

@@ -0,0 +1,64 @@
+require 'pact/mock_service/request_handlers/base_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class Options < BaseRequestHandler
+
+        attr_reader :name, :logger, :cors_enabled
+
+        HTTP_ACCESS_CONTROL_REQUEST_METHOD = "HTTP_ACCESS_CONTROL_REQUEST_METHOD".freeze
+        HTTP_ACCESS_CONTROL_REQUEST_HEADERS = "HTTP_ACCESS_CONTROL_REQUEST_HEADERS".freeze
+        ACCESS_CONTROL_ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials".freeze
+        ACCESS_CONTROL_ALLOW_ORIGIN = "Access-Control-Allow-Origin".freeze
+        ACCESS_CONTROL_ALLOW_METHODS = "Access-Control-Allow-Methods".freeze
+        ACCESS_CONTROL_ALLOW_HEADERS = "Access-Control-Allow-Headers".freeze
+        AUTHORIZATION = "authorization".freeze
+        COOKIE = "cookie".freeze
+        HTTP_ORIGIN = "HTTP_ORIGIN".freeze
+        ALL_METHODS = "DELETE, POST, GET, HEAD, PUT, TRACE, CONNECT, PATCH".freeze
+        REQUEST_METHOD = "REQUEST_METHOD".freeze
+        OPTIONS = "OPTIONS".freeze
+        X_PACT_MOCK_SERVICE_REGEXP = /x-pact-mock-service/i
+
+        def initialize name, logger, cors_enabled
+          @name = name
+          @logger = logger
+          @cors_enabled = cors_enabled
+        end
+
+        def match? env
+          is_options_request?(env) && (cors_enabled || is_administration_request?(env))
+        end
+
+        def respond env
+          cors_headers = {
+            ACCESS_CONTROL_ALLOW_ORIGIN => env.fetch(HTTP_ORIGIN,'*'),
+            ACCESS_CONTROL_ALLOW_HEADERS => env.fetch(HTTP_ACCESS_CONTROL_REQUEST_HEADERS, '*'),
+            ACCESS_CONTROL_ALLOW_METHODS => ALL_METHODS
+          }
+
+          if is_request_with_credentials?(env)
+            cors_headers[ACCESS_CONTROL_ALLOW_CREDENTIALS] = "true"
+          end
+
+          logger.info "Received OPTIONS request for mock service administration endpoint #{env[HTTP_ACCESS_CONTROL_REQUEST_METHOD]} #{env['PATH_INFO']}. Returning CORS headers: #{cors_headers}."
+          [200, cors_headers, []]
+        end
+
+        def is_options_request? env
+          env[REQUEST_METHOD] == OPTIONS
+        end
+
+        def is_administration_request? env
+          (env[HTTP_ACCESS_CONTROL_REQUEST_HEADERS] || '').match(X_PACT_MOCK_SERVICE_REGEXP)
+        end
+
+        def is_request_with_credentials? env
+          headers = (env[HTTP_ACCESS_CONTROL_REQUEST_HEADERS] || '').split(",").map { |header| header.strip.downcase }
+          headers.include?(AUTHORIZATION) || headers.include?(COOKIE)
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/request_handlers/pact_post.rb

@@ -0,0 +1,38 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+require 'pact/consumer_contract/consumer_contract_writer'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class PactPost < BaseAdministrationRequestHandler
+
+        attr_accessor :consumer_contract, :verified_interactions, :default_options, :session
+
+        def initialize name, logger, session
+          super name, logger
+          @verified_interactions = session.verified_interactions
+          @default_options = {}
+          @default_options.merge!(session.consumer_contract_details)
+          @session = session
+        end
+
+        def request_path
+          '/pact'
+        end
+
+        def request_method
+          'POST'
+        end
+
+        def respond env
+          body = env['rack.input'].string
+          consumer_contract_details = body.size > 0 ? JSON.parse(body, symbolize_names: true) : {}
+          consumer_contract_params = default_options.merge(consumer_contract_details.merge(interactions: verified_interactions))
+          consumer_contract_writer = ConsumerContractWriter.new(consumer_contract_params, logger)
+          session.record_pact_written
+          json_response(consumer_contract_writer.write)
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/request_handlers/session_delete.rb

@@ -0,0 +1,32 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      class SessionDelete < BaseAdministrationRequestHandler
+
+        attr_accessor :session
+
+        def initialize name, logger, session
+          super name, logger
+          @session = session
+        end
+
+        def request_path
+          '/session'
+        end
+
+        def request_method
+          'DELETE'
+        end
+
+        def respond env
+          session.clear_all
+          logger.info "Cleared session"
+          text_response 'Cleared session'
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/request_handlers/verification_get.rb

@@ -0,0 +1,74 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class VerificationGet < BaseAdministrationRequestHandler
+
+        def initialize name, logger, session
+          super name, logger
+          @expected_interactions = session.expected_interactions
+          @actual_interactions = session.actual_interactions
+        end
+
+        def request_path
+          '/interactions/verification'
+        end
+
+        def request_method
+          'GET'
+        end
+
+        def respond env
+          verification = Pact::MockService::Interactions::Verification.new(expected_interactions, actual_interactions)
+          example_desc = example_description(env)
+          example_desc = example_desc ? " for example #{example_desc.inspect}" : ''
+          if verification.all_matched?
+            logger.info "Verifying - interactions matched#{example_desc}"
+            text_response('Interactions matched')
+          else
+            error_message = FailureMessage.new(verification).to_s
+            logger.warn "Verifying - actual interactions do not match expected interactions#{example_desc}. \n#{error_message}"
+            logger.warn error_message
+            response_message = "Actual interactions do not match expected interactions for mock #{name}.\n\n#{error_message}See #{logger.description} for details."
+            text_response(response_message, 500)
+          end
+        end
+
+        private
+
+        attr_accessor :expected_interactions, :actual_interactions
+
+        def example_description env
+          params_hash(env).fetch("example_description", [])[0]
+        end
+
+        class FailureMessage
+
+          def initialize verification
+            @verification = verification
+          end
+
+          def to_s
+            titles_and_summaries.collect do | title, summaries |
+              "#{title}:\n\t#{summaries.join("\n\t")}\n\n" if summaries.any?
+            end.compact.join + verification.interaction_mismatches.collect(&:to_s).join("\n\n") + "\n"
+
+          end
+
+          private
+
+          attr_reader :verification
+
+          def titles_and_summaries
+            {
+              "Incorrect requests" => verification.interaction_mismatches_summaries,
+              "Missing requests" => verification.missing_interactions_summaries,
+              "Unexpected requests" => verification.unexpected_requests_summaries,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/request_handlers.rb

@@ -0,0 +1,42 @@
+require 'pact/mock_service/request_handlers/interaction_post'
+require 'pact/mock_service/request_handlers/interactions_put'
+require 'pact/mock_service/request_handlers/index_get'
+require 'pact/mock_service/request_handlers/interaction_delete'
+require 'pact/mock_service/request_handlers/interaction_replay'
+require 'pact/mock_service/request_handlers/log_get'
+require 'pact/mock_service/request_handlers/options'
+require 'pact/mock_service/request_handlers/missing_interactions_get'
+require 'pact/mock_service/request_handlers/pact_post'
+require 'pact/mock_service/request_handlers/session_delete'
+require 'pact/mock_service/request_handlers/verification_get'
+require 'pact/consumer/request'
+require 'pact/support'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      def self.new *args
+        App.new(*args)
+      end
+
+      class App < ::Rack::Cascade
+        def initialize name, logger, session, options
+          super [
+            Options.new(name, logger, options[:cors_enabled]),
+            SessionDelete.new(name, logger, session),
+            MissingInteractionsGet.new(name, logger, session),
+            VerificationGet.new(name, logger, session),
+            InteractionPost.new(name, logger, session, Pact::SpecificationVersion.new(options.fetch(:pact_specification_version))),
+            InteractionsPut.new(name, logger, session, Pact::SpecificationVersion.new(options.fetch(:pact_specification_version))),
+            InteractionDelete.new(name, logger, session),
+            LogGet.new(name, logger),
+            PactPost.new(name, logger, session),
+            IndexGet.new(name, logger),
+            InteractionReplay.new(name, logger, session, options[:cors_enabled], options[:stub_pactfile_paths])
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/response_decorator.rb

@@ -0,0 +1,31 @@
+module Pact
+  module MockService
+    class ResponseDecorator
+
+      def initialize response
+        @response = response
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      end
+
+      def as_json options = {}
+        to_hash
+      end
+
+      def to_hash
+        hash = {}
+        hash[:status]  = response.status  if response.specified?(:status)
+        hash[:headers] = response.headers if response.specified?(:headers)
+        hash[:body]    = response.body    if response.specified?(:body)
+        hash
+      end
+
+      private
+
+      attr_reader :response
+
+    end
+  end
+end

data/lib/pact/mock_service/run.rb

@@ -0,0 +1,125 @@
+require 'find_a_port'
+require 'pact/mock_service/app'
+require 'pact/consumer/mock_service/set_location'
+require 'pact/mock_service/run'
+require 'pact/mock_service/server/webrick_request_monkeypatch'
+require 'pact/specification_version'
+
+module Pact
+  module MockService
+    class Run
+
+      def self.call options
+        new(options).call
+      end
+
+      def initialize options
+        @options = options
+      end
+
+      def call
+        require 'pact/mock_service/app'
+
+        trap(:INT) { call_shutdown_hooks  }
+        trap(:TERM) { call_shutdown_hooks }
+
+        require_monkeypatch
+
+        Rack::Handler::WEBrick.run(mock_service, **webbrick_opts)
+      end
+
+      private
+
+      attr_reader :options
+
+      def mock_service
+        @mock_service ||= begin
+          mock_service = Pact::MockService.new(service_options)
+          Pact::Consumer::SetLocation.new(mock_service, base_url)
+        end
+      end
+
+      def call_shutdown_hooks
+        unless @shutting_down
+          @shutting_down = true
+          begin
+            mock_service.shutdown
+          ensure
+            Rack::Handler::WEBrick.shutdown
+          end
+        end
+      end
+
+      def service_options
+        # dummy pact_specification_version is needed to stop RequestHandlers blowing up
+        service_options = {
+          pact_dir: options[:pact_dir],
+          log_level: options[:log_level],
+          unique_pact_file_names: options[:unique_pact_file_names],
+          consumer: options[:consumer],
+          provider: options[:provider],
+          broker_token: options[:broker_token],
+          broker_username: options[:broker_username],
+          broker_password: options[:broker_password],
+          cors_enabled: options[:cors],
+          pact_specification_version: options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION.to_s,
+          pactfile_write_mode: options[:pact_file_write_mode],
+          stub_pactfile_paths: options[:stub_pactfile_paths]
+        }
+        service_options[:log_file] = open_log_file if options[:log]
+        service_options
+      end
+
+      def open_log_file
+        FileUtils.mkdir_p File.dirname(options[:log])
+        log = File.open(options[:log], 'w')
+        log.sync = true
+        log
+      end
+
+      def webbrick_opts
+        # By default, the webrick logs go to $stderr, which then show up as an ERROR
+        # log in pact-go, so it was changed to $stdout.
+        # $stdout needs sync = true for pact-js to determine the port dynamically from
+        # the output (otherwise it does not flush in time for the port to be read)
+        $stdout.sync = true
+        opts = {
+          :Port => port,
+          :Host => host,
+          :AccessLog => [],
+          :Logger => WEBrick::BasicLog.new($stdout)
+        }
+        opts.merge!({
+          :SSLCertificate => OpenSSL::X509::Certificate.new(File.open(options[:sslcert]).read) }) if options[:sslcert]
+        opts.merge!({
+          :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.open(options[:sslkey]).read) }) if options[:sslkey]
+        opts.merge!(ssl_opts) if options[:ssl]
+        opts.merge!(options[:webbrick_options]) if options[:webbrick_options]
+        opts
+      end
+
+      def ssl_opts
+        {
+          :SSLEnable => true,
+          :SSLCertName => [ ["CN", host] ]
+        }
+      end
+
+      def port
+        @port ||= (options[:port] || FindAPort.available_port).to_i
+      end
+
+      def host
+        @host ||= options[:host] || "localhost"
+      end
+
+      def base_url
+        options[:ssl] ? "https://#{host}:#{port}" : "http://#{host}:#{port}"
+      end
+
+      def require_monkeypatch
+        require options[:monkeypatch] if options[:monkeypatch]
+      end
+    end
+  end
+end

data/lib/pact/mock_service/server/respawn.rb

@@ -0,0 +1,20 @@
+require 'pact/mock_service/server/spawn'
+
+module Pact
+  module MockService
+    module Server
+      class Respawn
+
+        def self.call pidfile, port, ssl = false
+          if pidfile.file_exists_and_process_running?
+            pidfile.kill_process
+          end
+
+          Spawn.(pidfile, port, ssl) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/server/spawn.rb

@@ -0,0 +1,37 @@
+require 'pact/mock_service/server/wait_for_server_up'
+
+module Pact
+  module MockService
+    module Server
+      class Spawn
+
+        class PortUnavailableError < StandardError; end
+
+        def self.call pidfile, host, port, ssl = false
+          if pidfile.can_start?
+            if port_available? host, port
+              pid = fork do
+                yield
+              end
+              pidfile.pid = pid
+              Process.detach(pid)
+              Server::WaitForServerUp.(host, port, {ssl: ssl})
+              pidfile.write
+            else
+              raise PortUnavailableError.new("ERROR: Port #{port} already in use.")
+            end
+          end
+        end
+
+        def self.port_available? host, port
+          server = TCPServer.new(host, port)
+          true
+        rescue
+          false
+        ensure
+          server.close if server
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/server/wait_for_server_up.rb

@@ -0,0 +1,44 @@
+require 'timeout'
+require 'net/http'
+require 'openssl'
+
+module Pact
+  module MockService
+    module Server
+      class WaitForServerUp
+
+        def self.call(host, port, options = {ssl: false})
+          tries = 0
+          responsive = false
+          while !(responsive = responsive?(host, port, options)) && tries < 100
+            tries += 1
+            sleep 1
+          end
+          raise "Timed out waiting for server to start up on port #{port}" if !responsive
+        end
+
+        def self.responsive? host, port, options
+          http = Net::HTTP.new(host, port)
+          if options[:ssl]
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            scheme = 'https'
+          else
+            scheme = 'http'
+          end
+          http.start {
+            request = Net::HTTP::Get.new "#{scheme}://#{host}:#{port}/"
+            request['X-Pact-Mock-Service'] = true
+            response = http.request request
+            response.code == '200'
+          }
+        rescue SystemCallError => e
+          return false
+        rescue EOFError
+          return false
+        end
+      end
+
+    end
+  end
+end

data/lib/pact/mock_service/server/webrick_request_monkeypatch.rb

@@ -0,0 +1,15 @@
+module WEBrick
+  class HTTPRequest
+    alias_method :pact_original_meta_vars, :meta_vars
+
+    def meta_vars
+      original_underscored_headers = []
+      self.each{|key, val| original_underscored_headers << key if key.include?("_") }
+      # This header allows us to restore the original format (eg. underscored) of the headers
+      # when parsing the incoming Rack env back to a response object.
+      vars = pact_original_meta_vars
+      vars["X_PACT_UNDERSCORED_HEADER_NAMES"] = original_underscored_headers.join(",")
+      vars
+    end
+  end
+end

data/lib/pact/mock_service/session.rb

@@ -0,0 +1,96 @@
+require 'pact/mock_service/interactions/expected_interactions'
+require 'pact/mock_service/interactions/actual_interactions'
+require 'pact/mock_service/interactions/verified_interactions'
+require 'pact/mock_service/interaction_decorator'
+require 'pact/mock_service/interactions/interaction_diff_message'
+require 'pact/mock_service/errors'
+
+module Pact
+  module MockService
+    class Session
+
+      attr_reader :expected_interactions, :actual_interactions, :verified_interactions, :consumer_contract_details, :logger
+
+      def initialize options
+        @pact_written = false
+        @logger = options[:logger]
+        @expected_interactions = Interactions::ExpectedInteractions.new
+        @actual_interactions = Interactions::ActualInteractions.new
+        @verified_interactions = Interactions::VerifiedInteractions.new
+        @warn_on_too_many_interactions = options[:warn_on_too_many_interactions] || false
+        @max_concurrent_interactions_before_warning = get_max_concurrent_interactions_before_warning
+        @consumer_contract_details = {
+          pact_dir: options[:pact_dir],
+          consumer: {name: options[:consumer]},
+          provider: {name: options[:provider]},
+          interactions: verified_interactions,
+          pact_specification_version: options[:pact_specification_version],
+          pactfile_write_mode: options[:pactfile_write_mode]
+        }
+      end
+
+      def pact_written?
+        @pact_written
+      end
+
+      def record_pact_written
+        @pact_written = true
+      end
+
+      def set_expected_interactions interactions
+        clear_expected_and_actual_interactions
+        interactions.each do | interaction |
+          add_expected_interaction interaction
+        end
+      end
+
+      def clear_expected_and_actual_interactions
+        expected_interactions.clear
+        actual_interactions.clear
+      end
+
+      def clear_all
+        expected_interactions.clear
+        actual_interactions.clear
+        verified_interactions.clear
+        @pact_written = false
+      end
+
+      def add_expected_interaction interaction
+        if (previous_interaction = interaction_already_verified_with_same_description_and_provider_state_but_not_equal(interaction))
+          handle_almost_duplicate_interaction previous_interaction, interaction
+        else
+          really_add_expected_interaction interaction
+        end
+      end
+
+      private
+
+      attr_reader :warn_on_too_many_interactions, :max_concurrent_interactions_before_warning
+
+      def really_add_expected_interaction interaction
+        expected_interactions << interaction
+        logger.info "Registered expected interaction #{interaction.request.method_and_path}"
+        logger.debug JSON.pretty_generate InteractionDecorator.new(interaction)
+        if warn_on_too_many_interactions && expected_interactions.size > max_concurrent_interactions_before_warning
+          logger.warn "You currently have #{expected_interactions.size} interactions mocked at the same time. This suggests the scope of your consumer tests is larger than recommended, and you may find them hard to debug and maintain. See https://pact.io/too-many-interactions for more information."
+        end
+      end
+
+      def handle_almost_duplicate_interaction previous_interaction, interaction
+        message = Interactions::InteractionDiffMessage.new(previous_interaction, interaction).to_s
+        logger.error message
+        raise SameSameButDifferentError, message
+      end
+
+      def interaction_already_verified_with_same_description_and_provider_state_but_not_equal interaction
+        other = verified_interactions.find_matching_description_and_provider_state interaction
+        other && other != interaction ? other : nil
+      end
+
+      def get_max_concurrent_interactions_before_warning
+        ENV['PACT_MAX_CONCURRENT_INTERACTIONS_BEFORE_WARNING'] ? ENV['PACT_MAX_CONCURRENT_INTERACTIONS_BEFORE_WARNING'].to_i : 3
+      end
+    end
+  end
+end