pact-mock_service 0.0.1

data/lib/pact/consumer/interactions_filter.rb

@@ -0,0 +1,48 @@
+#
+# When running in pactfile_write_mode :overwrite, all interactions are cleared from the
+# pact file, and all new interactions should be distinct (unique description and provider state).
+# When running in pactfile_write_mode :update, an interaction with the same description
+# and provider state as an existing one will just overwrite that one interaction.
+#
+
+module Pact
+   module Consumer
+
+      #TODO: think of a better word than filter
+      class InteractionsFilter
+         def initialize interactions = []
+            @interactions = interactions
+         end
+
+         def index_of interaction
+            @interactions.find_index{ |i| i.matches_criteria?(description: interaction.description, provider_state: interaction.provider_state)}
+         end
+      end
+
+      class UpdatableInteractionsFilter < InteractionsFilter
+
+         def << interaction
+            if (ndx = index_of(interaction))
+               @interactions[ndx] = interaction
+            else
+               @interactions << interaction
+            end
+         end
+
+      end
+
+      class DistinctInteractionsFilter < InteractionsFilter
+
+         def << interaction
+            if (ndx = index_of(interaction))
+               if @interactions[ndx] != interaction
+                  raise "Interaction with same description (#{interaction.description}) and provider state (#{interaction.provider_state}) already exists"
+               end
+            else
+               @interactions << interaction
+            end
+         end
+      end
+
+   end
+end

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

@@ -0,0 +1,84 @@
+require 'rack'
+require 'uri'
+require 'json'
+require 'logger'
+require 'awesome_print'
+require 'awesome_print/core_ext/logger' #For some reason we get an error indicating that the method 'ap' is private unless we load this specifically
+require 'pact/consumer/request'
+require 'pact/consumer/mock_service/interaction_list'
+require 'pact/consumer/mock_service/interaction_delete'
+require 'pact/consumer/mock_service/interaction_post'
+require 'pact/consumer/mock_service/interaction_replay'
+require 'pact/consumer/mock_service/missing_interactions_get'
+require 'pact/consumer/mock_service/verification_get'
+require 'pact/consumer/mock_service/log_get'
+require 'pact/consumer/mock_service/pact_post'
+require 'pact/support'
+
+AwesomePrint.defaults = {
+  indent: -2,
+  plain: true,
+  index: false
+}
+
+module Pact
+  module Consumer
+
+    class MockService
+
+      def initialize options = {}
+        log_description = configure_logger options
+        interaction_list = InteractionList.new
+
+        @name = options.fetch(:name, "MockService")
+        interactions = []
+        @handlers = [
+          MissingInteractionsGet.new(@name, @logger, interaction_list),
+          VerificationGet.new(@name, @logger, interaction_list, log_description),
+          InteractionPost.new(@name, @logger, interaction_list),
+          InteractionDelete.new(@name, @logger, interaction_list),
+          LogGet.new(@name, @logger),
+          PactPost.new(@name, @logger, interactions),
+          InteractionReplay.new(@name, @logger, interaction_list, interactions)
+        ]
+      end
+
+      def configure_logger options
+        options = {log_file: $stdout}.merge options
+        log_stream = options[:log_file]
+        @logger = Logger.new log_stream
+        @logger.level = Pact.configuration.logger.level
+
+        if log_stream.is_a? File
+           File.absolute_path(log_stream).gsub(Dir.pwd + "/", '')
+        else
+          "standard out/err"
+        end
+      end
+
+      def to_s
+        "#{@name} #{super.to_s}"
+      end
+
+      def call env
+        response = []
+        begin
+          relevant_handler = @handlers.detect { |handler| handler.match? env }
+          response = relevant_handler.respond env
+        rescue StandardError => e
+          @logger.error 'Error ocurred in mock service:'
+          @logger.ap e, :error
+          @logger.ap e.backtrace
+          response = [500, {'Content-Type' => 'application/json'}, [{message: e.message, backtrace: e.backtrace}.to_json]]
+        rescue Exception => e
+          @logger.error 'Exception ocurred in mock service:'
+          @logger.ap e, :error
+          @logger.ap e.backtrace
+          raise e
+        end
+        response
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'pact/consumer/mock_service/rack_request_helper'
+require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+
+module Pact
+  module Consumer
+
+    class InteractionDelete < MockServiceAdministrationEndpoint
+
+      include RackRequestHelper
+
+      attr_accessor :interaction_list
+
+      def initialize name, logger, interaction_list
+        super name, logger
+        @interaction_list = interaction_list
+      end
+
+      def request_path
+        '/interactions'
+      end
+
+      def request_method
+        'DELETE'
+      end
+
+      def respond env
+        interaction_list.clear
+        logger.info "Cleared interactions before example \"#{params_hash(env)['example_description']}\""
+        [200, {}, ['Deleted interactions']]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Pact
+  module Consumer
+    class InteractionList
+
+      attr_reader :interactions
+      attr_reader :unexpected_requests
+      attr_reader :interaction_mismatches
+
+      def initialize
+        clear
+      end
+
+      # For testing, sigh
+      def clear
+        @interactions = []
+        @matched_interactions = []
+        @interaction_mismatches = []
+        @unexpected_requests = []
+      end
+
+      def add interactions
+        @interactions << interactions
+      end
+
+      def register_matched interaction
+        @matched_interactions << interaction
+      end
+
+      def register_unexpected_request request
+        @unexpected_requests << request
+      end
+
+      def register_interaction_mismatch interaction_mismatch
+        @interaction_mismatches << interaction_mismatch
+      end
+
+      def all_matched?
+        interaction_diffs.empty?
+      end
+
+      def missing_interactions
+        @interactions - @matched_interactions - @interaction_mismatches.collect(&:candidate_interactions).flatten
+      end
+
+      def missing_interactions_summaries
+        missing_interactions.collect(&:request).collect(&:method_and_path)
+      end
+
+      def interaction_mismatches_summaries
+        interaction_mismatches.collect(&:short_summary)
+      end
+
+      def unexpected_requests_summaries
+        unexpected_requests.collect(&:method_and_path)
+      end
+
+      def interaction_diffs
+        {
+          :missing_interactions => missing_interactions_summaries,
+          :interaction_mismatches => interaction_mismatches_summaries,
+          :unexpected_requests => unexpected_requests_summaries
+        }.inject({}) do | hash, pair |
+          hash[pair.first] = pair.last if pair.last.any?
+          hash
+        end
+      end
+
+      def find_candidate_interactions actual_request
+        interactions.select do | interaction |
+          interaction.request.matches_route? actual_request
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Pact
+  module Consumer
+
+    # Presents the differences between an actual request, and a list of
+    # expected interactions where the methods and paths match the actual request.
+    # This is used to display a helpful message to the user when a request
+    # comes in that doesn't match any of the expected interactions.
+    class InteractionMismatch
+
+      attr_accessor :candidate_interactions, :actual_request
+
+      # Assumes the method and path matches...
+
+      def initialize candidate_interactions, actual_request
+        @candidate_interactions = candidate_interactions
+        @actual_request = actual_request
+        @candiate_diffs = candidate_interactions.collect{ | candidate_interaction| CandidateDiff.new(candidate_interaction, actual_request)}
+      end
+
+      def to_hash
+        candiate_diffs.collect(&:to_hash)
+      end
+
+      def to_s
+        candiate_diffs.collect(&:to_s).join("\n")
+      end
+
+      def short_summary
+        mismatched_attributes = candiate_diffs.collect(&:mismatched_attributes).flatten.uniq.join(", ").reverse.sub(",", "dna ").reverse #OMG what a hack!
+        actual_request.method_and_path + " (request #{mismatched_attributes} did not match)"
+      end
+
+      private
+
+      attr_accessor :candiate_diffs
+
+      class CandidateDiff
+
+        attr_accessor :candidate_interaction, :actual_request
+
+        def initialize candidate_interaction, actual_request
+          @candidate_interaction = candidate_interaction
+          @actual_request = actual_request
+        end
+
+        def mismatched_attributes
+          diff.keys
+        end
+
+        def to_hash
+          summary = {:description => candidate_interaction.description}
+          summary[:provider_state] = candidate_interaction.provider_state if candidate_interaction.provider_state
+          summary.merge(diff)
+        end
+
+        def to_s
+          [
+            "Diff with interaction: #{candidate_interaction.description_with_provider_state_quoted}",
+            diff_formatter.call(diff, {colour: false})
+          ].join("\n")
+        end
+
+        def diff_formatter
+          Pact.configuration.diff_formatter_for_content_type(candidate_interaction.request.content_type)
+        end
+
+        def diff
+          @diff ||= candidate_interaction.request.difference(actual_request)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+
+module Pact
+  module Consumer
+    class InteractionPost < MockServiceAdministrationEndpoint
+
+      attr_accessor :interaction_list
+
+      def initialize name, logger, interaction_list
+        super name, logger
+        @interaction_list = interaction_list
+      end
+
+      def request_path
+        '/interactions'
+      end
+
+      def request_method
+        'POST'
+      end
+
+      def respond env
+        interaction = Interaction.from_hash(JSON.load(env['rack.input'].string))
+        interaction_list.add interaction
+        logger.info "Registered expected interaction #{interaction.request.method_and_path}"
+        logger.debug JSON.pretty_generate JSON.parse(interaction.to_json)
+        [200, {}, ['Added interaction']]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+require 'pact/matchers'
+require 'pact/consumer/mock_service/rack_request_helper'
+require 'pact/consumer/mock_service/interaction_mismatch'
+require 'pact/consumer_contract'
+require 'pact/consumer/interactions_filter'
+
+module Pact
+  module Consumer
+
+    class InteractionReplay
+      include Pact::Matchers
+      include RackRequestHelper
+
+      attr_accessor :name, :logger, :interaction_list, :interactions
+
+      def initialize name, logger, interaction_list, interactions
+        @name = name
+        @logger = logger
+        @interaction_list = interaction_list
+        @interactions = DistinctInteractionsFilter.new(interactions)
+      end
+
+      def match? env
+        true # default handler
+      end
+
+      def respond env
+        find_response request_as_hash_from(env)
+      end
+
+      private
+
+      def add_verified_interaction interaction
+        interactions << interaction
+      end
+
+      def find_response request_hash
+        actual_request = Request::Actual.from_hash(request_hash)
+        logger.info "Received request #{actual_request.method_and_path}"
+        logger.debug pretty_generate actual_request
+        candidate_interactions = interaction_list.find_candidate_interactions actual_request
+        matching_interactions = find_matching_interactions actual_request, from: candidate_interactions
+
+        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 find_matching_interactions actual_request, opts
+        candidate_interactions = opts.fetch(:from)
+        candidate_interactions.select do | candidate_interaction |
+          candidate_interaction.request.matches? actual_request
+        end
+      end
+
+      def handle_matched_interaction interaction
+        interaction_list.register_matched interaction
+        add_verified_interaction interaction
+        response = response_from(interaction.response)
+        logger.info "Found matching response for #{interaction.request.method_and_path}"
+        logger.debug pretty_generate(interaction.response)
+        response
+      end
+
+      def multiple_interactions_found_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]]
+      end
+
+      def handle_more_than_one_matching_interaction actual_request, matching_interactions
+        logger.error "Multiple interactions found for #{actual_request.method_and_path}:"
+        matching_interactions.each do | interaction |
+          logger.debug pretty_generate(interaction)
+        end
+        multiple_interactions_found_response actual_request, matching_interactions
+      end
+
+      def interaction_mismatch actual_request, candidate_interactions
+        InteractionMismatch.new(candidate_interactions, actual_request)
+      end
+
+      def request_summary_for interaction
+        summary = {:description => interaction.description}
+        summary[:provider_state] if interaction.provider_state
+        summary[:request] = interaction.request
+        summary
+      end
+
+      def unrecognised_request_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]]
+      end
+
+      def log_unrecognised_request_and_interaction_diff interaction_mismatch
+        logger.error "No matching interaction found on #{name} for #{interaction_mismatch.actual_request.method_and_path}"
+        logger.error 'Interaction diffs for that route:'
+        logger.error(interaction_mismatch.to_s)
+      end
+
+      def handle_unrecognised_request actual_request, candidate_interactions
+        interaction_mismatch = interaction_mismatch(actual_request, candidate_interactions)
+        if candidate_interactions.any?
+          interaction_list.register_interaction_mismatch interaction_mismatch
+        else
+          interaction_list.register_unexpected_request actual_request
+        end
+        log_unrecognised_request_and_interaction_diff interaction_mismatch
+        unrecognised_request_response interaction_mismatch
+      end
+
+      def response_from response
+        [response.status, (response.headers || {}).to_hash, [render_body(Pact::Reification.from_term(response.body))]]
+      end
+
+      def render_body body
+        return '' unless body
+        body.kind_of?(String) ? body.force_encoding('utf-8') : body.to_json
+      end
+
+      def logger_info_ap msg
+        logger.info msg
+      end
+
+      #Doesn't seem to reliably pretty generate unless we go to JSON and back again :(
+      def pretty_generate object
+        JSON.pretty_generate(JSON.parse(object.to_json))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+
+module Pact
+  module Consumer
+    class LogGet < MockServiceAdministrationEndpoint
+
+      include RackRequestHelper
+
+      def request_path
+        '/log'
+      end
+
+      def request_method
+        'GET'
+      end
+
+
+      def respond env
+        logger.info "Debug message from client - #{message(env)}"
+        [200, {}, []]
+      end
+
+      def message env
+        params_hash(env)['msg']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+
+module Pact
+  module Consumer
+
+    class MissingInteractionsGet < MockServiceAdministrationEndpoint
+      include RackRequestHelper
+
+      def initialize name, logger, interaction_list
+        super name, logger
+        @interaction_list = interaction_list
+      end
+
+      def request_path
+        '/interactions/missing'
+      end
+
+      def request_method
+        'GET'
+      end
+
+      def respond env
+        number_of_missing_interactions = @interaction_list.missing_interactions.size
+        logger.info "Number of missing interactions for mock \"#{name}\" = #{number_of_missing_interactions}"
+        [200, {}, [{size: number_of_missing_interactions}.to_json]]
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'pact/consumer/mock_service/rack_request_helper'
+module Pact
+  module Consumer
+    class MockServiceAdministrationEndpoint
+
+      attr_accessor :logger, :name
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      include RackRequestHelper
+
+      def match? env
+        headers_from(env)['X-Pact-Mock-Service'] &&
+        env['REQUEST_PATH'] == request_path &&
+          env['REQUEST_METHOD'] == request_method
+      end
+
+      def request_path
+        raise NotImplementedError
+      end
+
+      def request_method
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+require 'pact/consumer_contract/consumer_contract_writer'
+
+module Pact
+  module Consumer
+    class PactPost < MockServiceAdministrationEndpoint
+
+      attr_accessor :consumer_contract, :interactions
+
+      def initialize name, logger, interactions
+        super name, logger
+        @interactions = interactions
+      end
+
+      def request_path
+        '/pact'
+      end
+
+      def request_method
+        'POST'
+      end
+
+      def respond env
+        consumer_contract_details = JSON.parse(env['rack.input'].string, symbolize_names: true)
+        logger.info "Writing pact with details #{consumer_contract_details}"
+        consumer_contract_writer = ConsumerContractWriter.new(consumer_contract_details.merge(interactions: interactions), logger)
+        json = consumer_contract_writer.write
+
+        [200, {'Content-Type' =>'application/json'}, [json]]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Pact
+  module Consumer
+
+    module RackRequestHelper
+      REQUEST_KEYS = {
+        'REQUEST_METHOD' => :method,
+        'PATH_INFO' => :path,
+        'QUERY_STRING' => :query,
+        'rack.input' => :body
+      }
+
+      def params_hash env
+        env["QUERY_STRING"].split("&").collect{| param| param.split("=")}.inject({}){|params, param| params[param.first] = URI.decode(param.last); params }
+      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')}
+        headers.inject({}) do | hash, header |
+          hash[standardise_header(header.first)] = header.last
+          hash
+        end
+      end
+
+      def standardise_header header
+        header.gsub(/^HTTP_/, '').split("_").collect{|word| word[0] + word[1..-1].downcase}.join("-")
+      end
+    end
+  end
+end