hs-pact-mock_service 3.9.2

data/lib/pact/mock_service/interactions/verification.rb

@@ -0,0 +1,52 @@
+module Pact
+  module MockService
+    module Interactions
+      class Verification
+
+        def initialize expected_interactions, actual_interactions
+          @expected_interactions = expected_interactions
+          @actual_interactions = actual_interactions
+        end
+
+        def all_matched?
+          interaction_diffs.empty?
+        end
+
+        def interaction_diffs
+          {
+            :missing_interactions => missing_interactions_summaries,
+            :interaction_mismatches => interaction_mismatches_summaries,
+            :unexpected_requests => unexpected_requests_summaries
+          }.each_with_object({}) do | (key, value), hash |
+            hash[key] = value if value.any?
+          end
+        end
+
+        def missing_interactions_summaries
+          missing_interactions.collect(&:request).collect(&:method_and_path)
+        end
+
+        def interaction_mismatches_summaries
+          actual_interactions.interaction_mismatches.collect(&:short_summary)
+        end
+
+        def unexpected_requests_summaries
+          actual_interactions.unexpected_requests.collect(&:method_and_path)
+        end
+
+        def missing_interactions
+          expected_interactions - actual_interactions.matched_interactions - @actual_interactions.interaction_mismatches.collect(&:candidate_interactions).flatten
+        end
+
+        def interaction_mismatches
+          actual_interactions.interaction_mismatches
+        end
+
+        private
+
+        attr_reader :expected_interactions, :actual_interactions
+
+      end
+    end
+  end
+end

data/lib/pact/mock_service/interactions/verified_interactions.rb

@@ -0,0 +1,20 @@
+module Pact
+  module MockService
+    module Interactions
+      class VerifiedInteractions < Array
+
+        def << interaction
+          unless find_matching_description_and_provider_state interaction
+            super
+          end
+        end
+
+        def find_matching_description_and_provider_state interaction
+          find do |candidate_interaction|
+            candidate_interaction.matches_criteria?(description: interaction.description, provider_state: interaction.provider_state)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/logger.rb

@@ -0,0 +1,40 @@
+require 'logger'
+
+module Pact
+  module MockService
+    class Logger < ::Logger
+
+      attr_reader :description
+
+      def initialize stream
+        super stream
+        @description = if stream.is_a? File
+           File.absolute_path(stream).gsub(Dir.pwd + "/", '')
+        else
+          "standard out/err"
+        end
+      end
+
+      def self.from_options options
+        log_stream = options[:log_file] || $stdout
+        logger = new log_stream
+        logger.formatter = options[:log_formatter] if options[:log_formatter]
+        logger.level = logger_level(options[:log_level])
+        logger
+      end
+
+      def self.logger_level log_level_string
+        if log_level_string
+          begin
+            Kernel.const_get('Logger').const_get(log_level_string.upcase)
+          rescue NameError
+            $stderr.puts "WARN: Ignoring log level '#{log_level_string}' as it is not a valid value. Valid values are: DEBUG INFO WARN ERROR FATAL. Using DEBUG."
+            Logger::DEBUG
+          end
+        else
+          Logger::DEBUG
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/request_decorator.rb

@@ -0,0 +1,36 @@
+module Pact
+  module MockService
+    class RequestDecorator
+
+      def initialize request
+        @request = request
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      end
+
+      def as_json options = {}
+        to_hash
+      end
+
+      def to_hash
+        hash = {
+          method: request.method,
+          path: request.path,
+        }
+
+        hash[:query]   = request.query   if request.specified?(:query)
+        hash[:headers] = request.headers if request.specified?(:headers)
+        hash[:body]    = request.body    if request.specified?(:body)
+        hash[:options] = request.options if request.options.any?
+        hash
+      end
+
+      private
+
+      attr_reader :request
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'pact/consumer/mock_service/rack_request_helper'
+require 'pact/mock_service/request_handlers/base_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class BaseAdministrationRequestHandler < BaseRequestHandler
+
+        attr_accessor :logger, :name
+
+        def initialize name, logger
+          @name = name
+          @logger = logger
+        end
+
+        def match? env
+          has_mock_service_header?(env) && path_matches?(env) && method_matches?(env)
+        end
+
+        def has_mock_service_header? env
+          env['HTTP_X_PACT_MOCK_SERVICE']
+        end
+
+        def path_matches? env
+          env['PATH_INFO'].chomp("/") == request_path
+        end
+
+        def method_matches? env
+          env['REQUEST_METHOD'] == request_method
+        end
+
+        def request_path
+          raise NotImplementedError
+        end
+
+        def request_method
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'pact/consumer/mock_service/rack_request_helper'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class BaseRequestHandler
+
+        NOT_FOUND_RESPONSE = [404, {}, []].freeze
+
+        include Pact::Consumer::RackRequestHelper
+
+        def match? env
+          raise NotImplementedError
+        end
+
+        def call env
+          match?(env) ? respond(env) : NOT_FOUND_RESPONSE
+        end
+
+        def json_response json = nil, status = 200
+          [status, {'Content-Type' => 'application/json'}, json ? [json + "\n"]: []]
+        end
+
+        def text_response text = nil, status = 200
+          [status, {'Content-Type' => 'text/plain'}, text ? [text + "\n"]: []]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      class IndexGet < BaseAdministrationRequestHandler
+
+        def request_path
+          ''
+        end
+
+        def request_method
+          'GET'
+        end
+
+        def respond env
+          text_response('Mock service running')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      class InteractionDelete < BaseAdministrationRequestHandler
+
+        attr_accessor :session
+
+        def initialize name, logger, session
+          super name, logger
+          @session = session
+        end
+
+        def request_path
+          '/interactions'
+        end
+
+        def request_method
+          'DELETE'
+        end
+
+        def respond env
+          session.clear_expected_and_actual_interactions
+          example_desc = example_description(env)
+          example_desc = example_desc ? " for example #{example_desc.inspect}" : ''
+          logger.info "Cleared interactions#{example_desc}"
+          text_response('Cleared interactions')
+        end
+
+        def example_description env
+          params_hash(env).fetch('example_description', [])[0]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+require 'pact/mock_service/session'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class InteractionPost < BaseAdministrationRequestHandler
+
+        def initialize name, logger, session, pact_specification_version
+          super name, logger
+          @session = session
+          @pact_specification_version = pact_specification_version
+        end
+
+        def request_path
+          '/interactions'
+        end
+
+        def request_method
+          'POST'
+        end
+
+        def respond env
+          request_body = env['rack.input'].string
+          parsing_options = { pact_specification_version: pact_specification_version }
+          interaction = Interaction.from_hash(JSON.load(request_body), parsing_options) # Load creates the Pact::XXX classes
+
+          begin
+            session.add_expected_interaction interaction
+            text_response 'Registered interactions'
+          rescue ::Pact::Error => e
+            text_response e.message, 500
+          end
+
+        end
+
+        private
+
+        attr_accessor :session, :pact_specification_version
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+require 'pact/matchers'
+require 'pact/consumer/request'
+require 'pact/mock_service/interactions/interaction_mismatch'
+require 'pact/consumer_contract'
+require 'pact/mock_service/response_decorator'
+require 'pact/mock_service/interaction_decorator'
+require 'pact/mock_service/request_handlers/base_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      module PrettyGenerate
+        #Doesn't seem to reliably pretty generate unless we go to JSON and back again :(
+        def pretty_generate object
+          begin
+            JSON.pretty_generate(JSON.parse(object.to_json))
+          rescue
+            object.to_s
+          end
+        end
+      end
+
+      class InteractionReplay < BaseRequestHandler
+        include Pact::Matchers
+        include PrettyGenerate
+
+        attr_accessor :name, :logger, :expected_interactions, :actual_interactions, :verified_interactions, :multiple_interactions_handler
+
+        def initialize name, logger, session, cors_enabled = false, stub = false
+          @name = name
+          @logger = logger
+          @expected_interactions = session.expected_interactions
+          @actual_interactions = session.actual_interactions
+          @verified_interactions = session.verified_interactions
+          @cors_enabled = cors_enabled
+          @multiple_interactions_handler = stub ? HandleMultipleInteractionsFoundForStub : HandleMultipleInteractionsFound
+        end
+
+        def match? env
+          true # default handler
+        end
+
+        def respond env
+          find_response request_as_hash_from(env)
+        end
+
+        private
+
+        def find_response request_hash
+          actual_request = Pact::Consumer::Request::Actual.from_hash(request_hash)
+          logger.info "Received request #{actual_request.method_and_path}"
+          logger.debug pretty_generate request_hash
+          candidate_interactions = expected_interactions.find_candidate_interactions actual_request
+          matching_interactions = candidate_interactions.matching_interactions actual_request
+
+          case matching_interactions.size
+          when 0 then handle_unrecognised_request actual_request, candidate_interactions
+          when 1 then handle_matched_interaction matching_interactions.first
+          else
+            handle_more_than_one_matching_interaction actual_request, matching_interactions
+          end
+        end
+
+        def handle_matched_interaction interaction
+          HandleMatchedInteraction.call(interaction, verified_interactions, actual_interactions, logger)
+        end
+
+        def handle_more_than_one_matching_interaction actual_request, matching_interactions
+          multiple_interactions_handler.call(actual_request, matching_interactions, verified_interactions, actual_interactions, logger)
+        end
+
+        def handle_unrecognised_request actual_request, candidate_interactions
+          HandleUnrecognisedInteraction.call(actual_request, candidate_interactions, actual_interactions, logger)
+        end
+
+        def logger_info_ap msg
+          logger.info msg
+        end
+
+      end
+
+      class HandleMultipleInteractionsFound
+
+        extend PrettyGenerate
+
+        def self.call actual_request, matching_interactions, verified_interactions, actual_interactions, logger
+          logger.error "Multiple interactions found for #{actual_request.method_and_path}:"
+          matching_interactions.each do | interaction |
+            logger.debug pretty_generate(Pact::MockService::InteractionDecorator.new(interaction))
+          end
+          response actual_request, matching_interactions
+        end
+
+        def self.response actual_request, matching_interactions
+          response = {
+            message: "Multiple interaction found for #{actual_request.method_and_path}",
+            matching_interactions:  matching_interactions.collect{ | interaction | request_summary_for(interaction) }
+          }
+          [500, {'Content-Type' => 'application/json'}, [response.to_json + "\n"]]
+        end
+
+        def self.request_summary_for interaction
+          summary = {:description => interaction.description}
+          summary[:provider_state] if interaction.provider_state
+          summary[:request] = Pact::MockService::RequestDecorator.new(interaction.request)
+          summary
+        end
+      end
+
+      class HandleMultipleInteractionsFoundForStub
+
+        extend PrettyGenerate
+
+        def self.call actual_request, matching_interactions, verified_interactions, actual_interactions, logger
+          logger.warn "Multiple interactions found for #{actual_request.method_and_path}:"
+          matching_interactions.each do | interaction |
+            logger.debug pretty_generate(Pact::MockService::InteractionDecorator.new(interaction))
+          end
+          response actual_request, matching_interactions, verified_interactions, actual_interactions, logger
+        end
+
+        def self.response actual_request, matching_interactions, verified_interactions, actual_interactions, logger
+          logger.warn "Sorting responses by response status and returning first."
+          interaction = first_most_successful_interaction(matching_interactions)
+          HandleMatchedInteraction.call(interaction, verified_interactions, actual_interactions, logger)
+        end
+
+        def self.first_most_successful_interaction matching_interactions
+          matching_interactions.sort{ |i1, i2| Pact::Reification.from_term(i1.response.status) <=> Pact::Reification.from_term(i2.response.status) }.first
+        end
+      end
+
+      class HandleUnrecognisedInteraction
+
+        def self.call actual_request, candidate_interactions, actual_interactions, logger
+          interaction_mismatch = interaction_mismatch(actual_request, candidate_interactions)
+          if candidate_interactions.any?
+            actual_interactions.register_interaction_mismatch interaction_mismatch
+          else
+            actual_interactions.register_unexpected_request actual_request
+          end
+          log interaction_mismatch, logger
+          response interaction_mismatch
+        end
+
+        def self.response interaction_mismatch
+          response = {
+            message: "No interaction found for #{interaction_mismatch.actual_request.method_and_path}",
+            interaction_diffs:  interaction_mismatch.to_hash
+          }
+          [500, {'Content-Type' => 'application/json'}, [response.to_json + "\n"]]
+        end
+
+        def self.interaction_mismatch actual_request, candidate_interactions
+          Pact::MockService::Interactions::InteractionMismatch.new(candidate_interactions, actual_request)
+        end
+
+        def self.log interaction_mismatch, logger
+          logger.error "No matching interaction found for #{interaction_mismatch.actual_request.method_and_path}"
+          logger.error 'Interaction diffs for that route:'
+          logger.error(interaction_mismatch.to_s)
+        end
+
+      end
+
+      class HandleMatchedInteraction
+
+        extend PrettyGenerate
+
+        def self.call interaction, verified_interactions, actual_interactions, logger
+          actual_interactions.register_matched interaction
+          verified_interactions << interaction
+          response = response_from(interaction.response)
+          logger.info "Found matching response for #{interaction.request.method_and_path}"
+          logger.debug pretty_generate(Pact::MockService::ResponseDecorator.new(interaction.response))
+          response
+        end
+
+        def self.response_from response
+          [response.status, (Pact::Reification.from_term(response.headers) || {}).to_hash, [render_body(Pact::Reification.from_term(response.body))]]
+        end
+
+        def self.render_body body
+          return '' if body.nil?
+          body.kind_of?(String) ? body.force_encoding('utf-8') : body.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+require 'pact/mock_service/interaction_decorator'
+require 'pact/shared/json_differ'
+require 'pact/mock_service/request_handlers/interaction_post' #Refactor diff message
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class InteractionsPut < BaseAdministrationRequestHandler
+
+        def initialize name, logger, session, pact_specification_version
+          super name, logger
+          @session = session
+          @pact_specification_version = pact_specification_version
+        end
+
+        def request_path
+          '/interactions'
+        end
+
+        def request_method
+          'PUT'
+        end
+
+        def respond env
+          request_body = JSON.load(env['rack.input'].string)
+          parsing_options = { pact_specification_version: pact_specification_version }
+          interactions = request_body['interactions'].collect { | hash | Interaction.from_hash(hash, parsing_options) }
+          begin
+            session.set_expected_interactions interactions
+            text_response('Registered interactions')
+          rescue Pact::Error => e
+            text_response(e.message, 500)
+          end
+        end
+
+        private
+
+        attr_accessor :session, :pact_specification_version
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class LogGet < BaseAdministrationRequestHandler
+
+        def request_path
+          '/log'
+        end
+
+        def request_method
+          'GET'
+        end
+
+        def respond env
+          logger.info "Debug message from client - #{message(env)}"
+          text_response
+        end
+
+        def message env
+          params_hash(env).fetch('msg', [])[0]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+require 'pact/mock_service/interactions/verification'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      class MissingInteractionsGet < BaseAdministrationRequestHandler
+
+        def initialize name, logger, session
+          super name, logger
+          @expected_interactions = session.expected_interactions
+          @actual_interactions = session.actual_interactions
+        end
+
+        def request_path
+          '/interactions/missing'
+        end
+
+        def request_method
+          'GET'
+        end
+
+        def respond env
+          verification = Pact::MockService::Interactions::Verification.new(@expected_interactions, @actual_interactions)
+          number_of_missing_interactions = verification.missing_interactions.size
+          logger.info "Number of missing interactions for mock \"#{name}\" = #{number_of_missing_interactions}"
+          json_response({size: number_of_missing_interactions}.to_json)
+        end
+      end
+    end
+  end
+end