pact 1.0.9 → 1.0.10

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

@@ -0,0 +1,28 @@
+require 'pact/consumer/mock_service/rack_request_helper'
+
+module Pact
+  module Consumer
+
+    class InteractionDelete
+
+      include RackRequestHelper
+
+      def initialize name, logger, interaction_list
+        @name = name
+        @logger = logger
+        @interaction_list = interaction_list
+      end
+
+      def match? env
+        env['REQUEST_PATH'].start_with?('/interactions') &&
+          env['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,57 @@
+module Pact
+  module Consumer
+    class InteractionList
+
+      attr_reader :interactions
+      attr_reader :unexpected_requests
+
+      def initialize
+        clear
+      end
+
+      # For testing, sigh
+      def clear
+        @interactions = []
+        @matched_interactions = []
+        @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 all_matched?
+        interaction_diffs.empty?
+      end
+
+      def missing_interactions
+        @interactions - @matched_interactions
+      end
+
+      def interaction_diffs
+        {
+          :missing_interactions => missing_interactions.collect(&:as_json),
+          :unexpected_requests => unexpected_requests.collect(&:as_json)
+        }.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_post.rb

@@ -0,0 +1,25 @@
+module Pact
+  module Consumer
+    class InteractionPost
+
+      def initialize name, logger, interaction_list
+        @name = name
+        @logger = logger
+        @interaction_list = interaction_list
+      end
+
+      def match? env
+        env['REQUEST_PATH'] == '/interactions' &&
+          env['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} for #{@name}"
+        @logger.ap interaction.as_json
+        [200, {}, ['Added interactions']]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require 'pact/matchers'
+require 'pact/consumer/mock_service/rack_request_helper'
+
+module Pact
+  module Consumer
+
+    class InteractionReplay
+      include Pact::Matchers
+      include RackRequestHelper
+
+      def initialize name, logger, interaction_list
+        @name = name
+        @logger = logger
+        @interaction_list = interaction_list
+      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 = Request::Actual.from_hash(request_hash)
+        @logger.info "#{@name} received request #{actual_request.method_and_path}"
+        @logger.ap actual_request.as_json
+        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
+        response = response_from(interaction.response)
+        @logger.info "Found matching response on #{@name}:"
+        @logger.ap 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 on #{@name}:"
+        @logger.ap matching_interactions.collect(&:as_json)
+        multiple_interactions_found_response actual_request, matching_interactions
+      end
+
+      def interaction_diffs actual_request, candidate_interactions
+        candidate_interactions.collect do | candidate_interaction |
+          diff = candidate_interaction.request.difference(actual_request)
+          diff_summary_for candidate_interaction, diff
+        end        
+      end
+
+      def diff_summary_for interaction, diff
+        summary = {:description => interaction.description}
+        summary[:provider_state] = interaction.provider_state if interaction.provider_state
+        summary.merge(diff)
+      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 actual_request, interaction_diffs
+        response = {
+          message: "No interaction found for #{actual_request.method_and_path}", 
+          interaction_diffs:  interaction_diffs
+        }
+        [500, {'Content-Type' => 'application/json'}, [response.to_json]]
+      end
+
+      def log_unrecognised_request_and_interaction_diff actual_request, interaction_diffs, candidate_interactions
+        @logger.error "No interaction found on #{@name} for #{actual_request.method_and_path}"
+        @logger.error 'Interaction diffs for that route:'
+        @logger.ap(interaction_diffs, :error)        
+      end
+
+      def handle_unrecognised_request actual_request, candidate_interactions
+        @interaction_list.register_unexpected_request actual_request
+        interaction_diffs = interaction_diffs(actual_request, candidate_interactions)
+        log_unrecognised_request_and_interaction_diff actual_request, interaction_diffs, candidate_interactions
+        unrecognised_request_response actual_request, interaction_diffs
+      end
+
+      def response_from response
+        [response['status'], (response['headers'] || {}).to_hash, [render_body(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
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Pact
+  module Consumer
+
+    class MissingInteractionsGet
+      include RackRequestHelper
+
+      def initialize name, logger, interaction_list
+        @name = name
+        @logger = logger
+        @interaction_list = interaction_list
+      end
+
+      def match? env
+        env['REQUEST_PATH'].start_with?('/number_of_missing_interactions') &&
+            env['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, {}, ["#{number_of_missing_interactions}"]]
+      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,
+        'REQUEST_PATH' => :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')}
+        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

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

@@ -0,0 +1,22 @@
+module Pact
+  module Consumer
+
+    class StartupPoll
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      def match? env
+        env['REQUEST_PATH'] == '/index.html' &&
+          env['REQUEST_METHOD'] == 'GET'
+      end
+
+      def respond env
+        @logger.info "#{@name} started up"
+        [200, {}, ['Started up fine']]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Pact
+  module Consumer
+    class VerificationGet
+
+      include RackRequestHelper
+
+      def initialize name, logger, log_description, interaction_list
+        @name = name
+        @logger = logger
+        @log_description = log_description
+        @interaction_list = interaction_list
+      end
+
+      def match? env
+        env['REQUEST_PATH'].start_with?('/verify') &&
+          env['REQUEST_METHOD'] == 'GET'
+      end
+
+      def respond env
+        if @interaction_list.all_matched?
+          @logger.info "Verifying - interactions matched for example \"#{example_description(env)}\""
+          [200, {}, ['Interactions matched']]
+        else
+          @logger.warn "Verifying - actual interactions do not match expected interactions for example \"#{example_description(env)}\". Interaction diffs:"
+          @logger.ap @interaction_list.interaction_diffs, :warn
+          [500, {}, ["Actual interactions do not match expected interactions for mock #{@name}. See #{@log_description} for details."]]
+        end
+      end
+
+      def example_description env
+        params_hash(env)['example_description']
+      end
+    end
+  end
+end

data/lib/pact/consumer/mock_service_client.rb

@@ -1,3 +1,5 @@
+require 'pact/consumer/mock_service_interaction_expectation'
+
 module Pact
   module Consumer
     class MockServiceClient
@@ -22,7 +24,7 @@ module Pact
       end
 
       def add_expected_interaction interaction
-        http.request_post('/interactions', interaction.to_json_for_mock_service)
+        http.request_post('/interactions', MockServiceInteractionExpectation.new(interaction).to_json)
       end
 
       def self.clear_interactions port, example_description

data/lib/pact/consumer/mock_service_interaction_expectation.rb

@@ -0,0 +1,33 @@
+require 'pact/reification'
+
+# Represents the Interaction in the form required by the MockService
+# The json generated will be posted to the MockService to register the expectation
+module Pact
+  module Consumer
+    class MockServiceInteractionExpectation
+
+
+      def initialize interaction
+        @interaction = interaction
+      end
+
+      def as_json
+        hash = {:description => interaction.description}
+        hash[:provider_state] = interaction.provider_state if interaction.provider_state
+        options = interaction.request.options.empty? ? {} : { options: interaction.request.options}
+        hash[:request] = interaction.request.as_json.merge(options)
+        hash[:response] = Reification.from_term(interaction.response)
+        hash
+      end
+
+      def to_json opts = {}
+        as_json.to_json(opts)
+      end
+
+      private
+
+      attr_reader :interaction
+
+    end
+  end
+end

data/lib/pact/consumer/request.rb

@@ -0,0 +1,27 @@
+require 'pact/shared/request'
+require 'pact/shared/key_not_found'
+
+module Pact
+  module Consumer
+    module Request
+      class Actual < Pact::Request::Base
+
+        def self.from_hash(hash)
+          sym_hash = symbolize_keys hash
+          method = sym_hash.fetch(:method)
+          path = sym_hash.fetch(:path)
+          query = sym_hash.fetch(:query)
+          headers = sym_hash.fetch(:headers)
+          body = sym_hash.fetch(:body, nil)
+          new(method, path, headers, body, query)
+        end
+
+        protected
+
+        def self.key_not_found
+          nil
+        end       
+      end      
+    end
+  end
+end