hs-pact-mock_service 3.9.2

data/lib/pact/consumer/mock_service/cors_origin_header_middleware.rb

@@ -0,0 +1,31 @@
+module Pact
+  module Consumer
+    class CorsOriginHeaderMiddleware
+
+      def initialize app, cors_enabled
+        @app = app
+        @cors_enabled = cors_enabled
+      end
+
+      def call env
+        response = @app.call env
+        if env['HTTP_X_PACT_MOCK_SERVICE'] || @cors_enabled
+          add_cors_header env, response
+        else
+          response
+        end
+      end
+
+      def shutdown
+        @app.shutdown
+      end
+
+      private
+
+      def add_cors_header env, response
+        cors_headers = { 'Access-Control-Allow-Origin' => env.fetch('HTTP_ORIGIN','*'), 'Access-Control-Allow-Credentials' => 'true'}
+        [response[0], response[1].merge(cors_headers), response[2]]
+      end
+    end
+  end
+end

data/lib/pact/consumer/mock_service/error_handler.rb

@@ -0,0 +1,31 @@
+module Pact
+  module Consumer
+    class MockService
+      class ErrorHandler
+
+        def initialize app, logger
+          @app = app
+          @logger = logger
+        end
+
+        def call env
+          begin
+            @app.call(env)
+          rescue Pact::Error => e
+            @logger.error e.message
+            [500, {'Content-Type' => 'application/json'}, [{message: e.message}.to_json]]
+          rescue StandardError => e
+            message = "Error ocurred in mock service: #{e.class} - #{e.message}"
+            @logger.error message
+            @logger.error e.backtrace.join("\n")
+            [500, {'Content-Type' => 'application/json'}, [{message: message, backtrace: e.backtrace}.to_json]]
+          end
+        end
+
+        def shutdown
+          @app.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/mock_service/rack_request_helper.rb

@@ -0,0 +1,65 @@
+require 'cgi/core'
+require 'pact/consumer_contract/query'
+
+module Pact
+  module Consumer
+
+    module RackRequestHelper
+      REQUEST_KEYS = {
+        'REQUEST_METHOD' => :method,
+        'PATH_INFO' => :path,
+        'QUERY_STRING' => :query,
+        'rack.input' => :body
+      }
+
+      def params_hash env
+        Pact::Query.parse_string(env["QUERY_STRING"])
+      end
+
+      def request_as_hash_from env
+        request = env.inject({}) do |memo, (k, v)|
+          request_key = REQUEST_KEYS[k]
+          memo[request_key] = v if request_key
+          memo
+        end
+
+        request[:headers] = headers_from env
+        body_string = request[:body].read
+
+        if body_string.empty?
+          request.delete :body
+        else
+          body_is_json = request[:headers]['Content-Type'] =~ /json/
+          request[:body] =  body_is_json ? JSON.parse(body_string) : body_string
+        end
+        request[:method] = request[:method].downcase
+        request
+      end
+
+      private
+
+      def headers_from env
+        headers = env.reject{ |key, value| !(key.start_with?("HTTP") || key == 'CONTENT_TYPE' || key == 'CONTENT_LENGTH')}
+        dasherized_headers = headers.inject({}) do | hash, header |
+          hash[standardise_header(header.first)] = header.last
+          hash
+        end
+        # This header is set in lib/pact/mock_service/server/webrick_request_monkeypatch.rb to allow use to
+        # restore the original header names with underscores.
+        restore_underscored_header_names(dasherized_headers, (env['X_PACT_UNDERSCORED_HEADER_NAMES'] || '').split(","))
+      end
+
+      def standardise_header header
+        header.gsub(/^HTTP_/, '').split(/[_-]/).collect{|word| word[0].upcase + word[1..-1].downcase}.join("-")
+      end
+
+      def restore_underscored_header_names dasherized_headers, original_header_names
+        original_header_names.each_with_object(dasherized_headers) do | original_header_name, headers |
+          if headers.key?(standardise_header(original_header_name))
+            headers[original_header_name] = headers.delete(standardise_header(original_header_name))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/mock_service/set_location.rb

@@ -0,0 +1,28 @@
+module Pact
+  module Consumer
+    class SetLocation
+
+      LOCATION = 'X-Pact-Mock-Service-Location'.freeze
+      HTTP_X_PACT_MOCK_SERVICE = 'HTTP_X_PACT_MOCK_SERVICE'
+
+      def initialize app, base_url
+        @app = app
+        @location_header = {LOCATION => base_url}.freeze
+      end
+
+      def call env
+        response = @app.call(env)
+        env[HTTP_X_PACT_MOCK_SERVICE] ? add_location_header_to_response(response) : response
+      end
+
+      def add_location_header_to_response response
+        [response.first, response[1].merge(@location_header), response.last]
+      end
+
+      def shutdown
+        @app.shutdown
+      end
+
+    end
+  end
+end

data/lib/pact/consumer/server.rb

@@ -0,0 +1,111 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+
+# Copied shamelessly from Capybara
+# Used to run a mock service in a new thread when started by the AppManager or the ControlServer
+
+module Pact
+  class Server
+    class Middleware
+      attr_accessor :error
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env["PATH_INFO"] == "/__identify__"
+          [200, {}, [@app.object_id.to_s]]
+        else
+          begin
+            @app.call(env)
+          rescue StandardError => e
+            @error = e unless @error
+            raise e
+          end
+        end
+      end
+    end
+
+    class << self
+      def ports
+        @ports ||= {}
+      end
+    end
+
+    attr_reader :app, :host, :port, :options
+
+    def initialize(app, host, port, options = {})
+      @app = app
+      @middleware = Middleware.new(@app)
+      @server_thread = nil
+      @host = host
+      @port = port
+      @options = options
+    end
+
+    def reset_error!
+      @middleware.error = nil
+    end
+
+    def error
+      @middleware.error
+    end
+
+    def responsive?
+      return false if @server_thread && @server_thread.join(0)
+      res = get_identity
+      if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
+        return res.body == @app.object_id.to_s
+      end
+    rescue SystemCallError
+      return false
+    rescue EOFError
+      return false
+    end
+
+    def run_default_server(app, port)
+      require 'rack/handler/webrick'
+      Rack::Handler::WEBrick.run(app, **webrick_opts) do |server|
+        @port = server[:Port]
+      end
+    end
+
+    def get_identity
+      return false unless @port
+      http = Net::HTTP.new host, @port
+      if options[:ssl]
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      http.get('/__identify__')
+    end
+
+    def webrick_opts
+      opts = { Host: host.nil? ? 'localhost' : host, Port: port.nil? ? 0 : port, AccessLog: [], Logger: WEBrick::Log::new(nil, 0) }
+      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
+    end
+
+    def ssl_opts
+      { SSLEnable: true, SSLCertName: [ ["CN", host] ] }
+    end
+
+    def boot
+      unless responsive?
+        @server_thread = Thread.new { run_default_server(@middleware, @port) }
+        Timeout.timeout(60) { @server_thread.join(0.1) until responsive? }
+      end
+    rescue Timeout::Error
+      raise "Rack application timed out during boot"
+    else
+      Pact::Server.ports[@app.object_id] = @port
+      self
+    end
+  end
+end

data/lib/pact/consumer_contract/consumer_contract_decorator.rb

@@ -0,0 +1,53 @@
+require 'pact/shared/active_support_support'
+require 'pact/consumer_contract/interaction_decorator'
+
+module Pact
+  class ConsumerContractDecorator
+
+    include ActiveSupportSupport
+
+    def initialize consumer_contract, decorator_options = {}
+      @consumer_contract = consumer_contract
+      @decorator_options = decorator_options
+    end
+
+    def as_json(options = {})
+      fix_all_the_things(
+        consumer: consumer_contract.consumer.as_json,
+        provider: consumer_contract.provider.as_json,
+        interactions: sorted_interactions.collect{ |i| InteractionDecorator.new(i, @decorator_options).as_json},
+        metadata: {
+          pactSpecification: {
+            version: pact_specification_version
+          }
+        }
+      )
+    end
+
+    def to_json(options = {})
+      as_json.to_json(options)
+    end
+
+    private
+
+    def sorted_interactions
+      # Default order: chronological
+      return consumer_contract.writable_interactions if Pact.configuration.pactfile_write_order == :chronological
+      # We are supporting only chronological or alphabetical order
+      raise NotImplementedError if Pact.configuration.pactfile_write_order != :alphabetical
+
+      consumer_contract.writable_interactions.sort{|a, b| sortable_id(a) <=> sortable_id(b)}
+    end
+
+    def sortable_id interaction
+      "#{interaction.description.downcase} #{interaction.response.status} #{(interaction.provider_state || '').downcase}"
+    end
+
+    attr_reader :consumer_contract
+
+    def pact_specification_version
+      version = @decorator_options.fetch(:pact_specification_version)
+      "#{version[0]}.0.0" # Only care about the first digit
+    end
+  end
+end

data/lib/pact/consumer_contract/consumer_contract_writer.rb

@@ -0,0 +1,181 @@
+require 'pact/consumer_contract'
+require 'pact/mock_service/interactions/interactions_filter'
+require 'pact/consumer_contract/file_name'
+require 'pact/consumer_contract/pact_file'
+require 'pact/consumer_contract/consumer_contract_decorator'
+require 'pact/shared/active_support_support'
+require 'fileutils'
+require 'filelock'
+
+module Pact
+
+  class ConsumerContractWriterError < StandardError; end
+
+  class ConsumerContractWriter
+
+    DEFAULT_PACT_SPECIFICATION_VERSION = '2.0.0'
+
+    include Pact::FileName
+    include Pact::PactFile
+    include ActiveSupportSupport
+
+    def initialize consumer_contract_details, logger
+      @logger = logger
+      @consumer_contract_details = consumer_contract_details
+      @pactfile_write_mode = (consumer_contract_details[:pactfile_write_mode] || :overwrite).to_sym
+      @interactions = consumer_contract_details.fetch(:interactions)
+      @pact_specification_version = (consumer_contract_details[:pact_specification_version] || DEFAULT_PACT_SPECIFICATION_VERSION).to_s
+      @consumer_contract_decorator_class = consumer_contract_details[:consumer_contract_decorator_class] || Pact::ConsumerContractDecorator
+      @error_stream = consumer_contract_details[:error_stream] || Pact.configuration.error_stream
+      @output_stream = consumer_contract_details[:output_stream] || Pact.configuration.output_stream
+    end
+
+    def consumer_contract
+      @consumer_contract ||= Pact::ConsumerContract.new(
+        consumer: ServiceConsumer.new(name: consumer_contract_details[:consumer][:name]),
+        provider: ServiceProvider.new(name: consumer_contract_details[:provider][:name]),
+        interactions: interactions_for_new_consumer_contract)
+    end
+
+    def write
+      update_pactfile_if_needed
+      pact_json
+    end
+
+    def can_write?
+      consumer_name && provider_name && consumer_contract_details[:pact_dir]
+    end
+
+    private
+
+    attr_reader :consumer_contract_details, :pactfile_write_mode, :interactions, :logger, :pact_specification_version, :consumer_contract_decorator_class
+    attr_reader :error_stream, :output_stream
+
+    def update_pactfile_if_needed
+      return if pactfile_write_mode == :none
+      return if interactions.count == 0
+      update_pactfile
+    end
+
+    def update_pactfile
+      logger.info log_message
+      FileUtils.mkdir_p File.dirname(pactfile_path)
+      Filelock(pactfile_path) do | pact_file |
+        # must be read after obtaining the lock, and must be read from the yielded file object, otherwise windows freaks out
+        @existing_contents = pact_file.read
+        new_contents = pact_json
+        pact_file.rewind
+        pact_file.truncate 0
+        pact_file.write new_contents
+        pact_file.flush
+        pact_file.truncate(pact_file.pos)
+      end
+    end
+
+    def pact_json
+      @pact_json ||= fix_json_formatting(JSON.pretty_generate(decorated_pact))
+    end
+
+    def decorated_pact
+      @decorated_pact ||= consumer_contract_decorator_class.new(consumer_contract, pact_specification_version: pact_specification_version)
+    end
+
+    def interactions_for_new_consumer_contract
+      if pactfile_exists? && (updating? || merging?)
+        merged_interactions = existing_interactions.dup
+        filter = Pact::MockService::Interactions.filter(merged_interactions, pactfile_write_mode)
+        interactions.each {|i| filter << i }
+        merged_interactions
+      else
+        interactions
+      end
+    end
+
+    def existing_interactions
+      interactions = []
+      if pactfile_exists? && pactfile_has_contents?
+        begin
+          interactions = existing_consumer_contract.interactions
+          print_updating_warning if updating?
+        rescue StandardError => e
+          warn_and_stderr "Could not load existing consumer contract from #{pactfile_path} due to #{e}. Creating a new file."
+          logger.error e
+          logger.error e.backtrace
+        end
+      end
+      interactions
+    end
+
+    def pactfile_exists?
+      File.exist?(pactfile_path)
+    end
+
+    def pactfile_has_contents?
+      File.size(pactfile_path) != 0
+    end
+
+    def existing_contents
+      @existing_contents
+    end
+
+    def existing_consumer_contract
+      @existing_consumer_contract ||= Pact::ConsumerContract.from_json(existing_contents)
+    end
+
+    def warn_and_stderr msg
+      error_stream.puts msg
+      logger.warn msg
+    end
+
+    def info_and_puts msg
+      output_stream.puts msg
+      logger.info msg
+    end
+
+    def consumer_name
+      consumer_contract_details[:consumer][:name]
+    end
+
+    def provider_name
+      consumer_contract_details[:provider][:name]
+    end
+
+    def pactfile_path
+      raise 'You must specify a consumer and provider name' unless (consumer_name && provider_name)
+      file_path consumer_name, provider_name, pact_dir, unique: consumer_contract_details[:unique_pact_file_names]
+    end
+
+    def pact_dir
+      unless consumer_contract_details[:pact_dir]
+        raise ConsumerContractWriterError.new("Please indicate the directory to write the pact to by specifying the pact_dir field")
+      end
+      consumer_contract_details[:pact_dir]
+    end
+
+    def updating?
+      pactfile_write_mode == :update
+    end
+
+    def merging?
+      pactfile_write_mode == :merge
+    end
+
+    def log_message
+      if updating?
+        "Updating pact for #{provider_name} at #{pactfile_path}"
+      elsif merging?
+        "Merging interactions into pact for #{provider_name} at #{pactfile_path}"
+      else
+        "Writing pact for #{provider_name} to #{pactfile_path}"
+      end
+    end
+
+    def print_updating_warning
+      info_and_puts "*****************************************************************************"
+      info_and_puts "Updating existing file .#{pactfile_path.gsub(Dir.pwd, '')} as pactfile_write_mode is :update"
+      info_and_puts "Only interactions defined in this test run will be updated."
+      info_and_puts "As interactions are identified by description and provider state, pleased note that if either of these have changed, the old interactions won't be removed from the pact file until the specs are next run with :pactfile_write_mode => :overwrite."
+      info_and_puts "*****************************************************************************"
+    end
+  end
+end

data/lib/pact/consumer_contract/interaction_decorator.rb

@@ -0,0 +1,40 @@
+require 'pact/shared/active_support_support'
+require 'pact/consumer_contract/request_decorator'
+require 'pact/consumer_contract/response_decorator'
+
+module Pact
+  class InteractionDecorator
+
+    include ActiveSupportSupport
+
+    def initialize interaction, decorator_options = {}
+      @interaction = interaction
+      @decorator_options = decorator_options
+    end
+
+    def as_json options = {}
+      hash = { :description => interaction.description }
+      hash[:providerState] = interaction.provider_state if interaction.provider_state
+      hash[:request] = decorate_request.as_json(options)
+      hash[:response] = decorate_response.as_json(options)
+      fix_all_the_things hash
+    end
+
+    def to_json(options = {})
+      as_json(options).to_json(options)
+    end
+
+    private
+
+    attr_reader :interaction
+
+    def decorate_request
+      RequestDecorator.new(interaction.request, @decorator_options)
+    end
+
+    def decorate_response
+      ResponseDecorator.new(interaction.response, @decorator_options)
+    end
+
+  end
+end

data/lib/pact/consumer_contract/request_decorator.rb

@@ -0,0 +1,88 @@
+require 'pact/reification'
+
+module Pact
+  class RequestDecorator
+
+    def initialize request, decorator_options = {}
+      @request = request
+      @decorator_options = decorator_options
+    end
+
+    def to_json(options = {})
+      as_json.to_json(options)
+    end
+
+    def as_json options = {}
+      hash = to_hash_without_rules
+      include_matching_rules? ? with_matching_rules(hash) : hash
+    end
+
+    private
+
+    attr_reader :request
+
+    def to_hash_without_rules
+      hash = {
+        method: request.method,
+        path: path
+      }
+      hash[:query]   = query   if request.specified?(:query)
+      hash[:headers] = headers if request.specified?(:headers)
+      hash[:body]    = body    if request.specified?(:body)
+      hash
+    end
+
+    def path
+      Pact::Reification.from_term(request.path)
+    end
+
+    def query
+      Pact::Reification.from_term(request.query)
+    end
+
+    def headers
+      Pact::Reification.from_term(request.headers)
+    end
+
+    # This feels wrong to be checking the class type of the body
+    # Do this better somehow.
+    def body
+      if content_type_is_form && request.body.is_a?(Hash)
+        URI.encode_www_form convert_hash_body_to_array_of_arrays
+      else
+        Pact::Reification.from_term(request.body)
+      end
+    end
+
+    def content_type_is_form
+      request.content_type? 'application/x-www-form-urlencoded'
+    end
+
+    #This probably belongs somewhere else.
+    def convert_hash_body_to_array_of_arrays
+      arrays = []
+      request.body.keys.each do | key |
+        [*request.body[key]].each do | value |
+          arrays << [key, value]
+        end
+      end
+
+      Pact::Reification.from_term(arrays)
+    end
+
+    def include_matching_rules?
+      pact_specification_version && !pact_specification_version.start_with?('1')
+    end
+
+    def with_matching_rules hash
+      matching_rules = Pact::MatchingRules.extract request.to_hash
+      return hash if matching_rules.empty?
+      hash.merge(matchingRules: matching_rules)
+    end
+
+    def pact_specification_version
+      @decorator_options[:pact_specification_version]
+    end
+
+  end
+end

data/lib/pact/consumer_contract/response_decorator.rb

@@ -0,0 +1,47 @@
+require 'pact/matching_rules'
+require 'pact/term'
+
+module Pact
+  class ResponseDecorator
+
+    def initialize response, decorator_options = {}
+      @response = response
+      @decorator_options = decorator_options
+    end
+
+    def to_json(options = {})
+      as_json.to_json(options)
+    end
+
+    def as_json options = {}
+      include_matching_rules? ? with_matching_rules(attributes_hash) : attributes_hash
+    end
+
+    private
+
+    attr_reader :response
+
+    def attributes_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
+
+    def include_matching_rules?
+      pact_specification_version && !pact_specification_version.start_with?('1')
+    end
+
+    def with_matching_rules hash
+      matching_rules = Pact::MatchingRules.extract hash
+      example = Pact::Reification.from_term hash
+      return example if matching_rules.empty?
+      example.merge(matchingRules: matching_rules)
+    end
+
+    def pact_specification_version
+      @decorator_options[:pact_specification_version]
+    end
+  end
+end