pact-mock_service 0.2.2 → 0.2.3.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fac0922931cca9e297ccfc60904ef05c85ff1be6
-  data.tar.gz: a6347beea927a7640ecc44fa9595b8c64f86f860
+  metadata.gz: 1e4c79027ecd3c1da41ed2b2305c7d02ab8422bb
+  data.tar.gz: b6900749dbe4f721b7c958d2522caa6fdabf0fe4
 SHA512:
-  metadata.gz: ff2fc19751548ef67b862bce43420ee777b4176e98bd4dfcf2f45aa99bdabce7b45848d8c4c8c2eec1e60b9b433b3fa8cdb18d101ad1261b5d9fb88ff1bcc64f
-  data.tar.gz: f3bc038ac5ed668178090ad5e578fb450c940aa7fd097868b89c5a154c6481ce8357028892672e4ae1f810155a1fd8841dbdc0e7ae0392dd4a2580a2caa4801d
+  metadata.gz: 8945a97c67fc3f7d6531a963f9325690781e95914f37b41e8ab091fc45bdeaedec1907ec6fc84d42c12fe660f7a343a0cec7396bf519b378cfed4a4abd0b4795
+  data.tar.gz: a3c82d60ef644fd1057f2188d6d86571f026d1e59b8fc7333e8a14b91b8b397affb4558bfdc6dfb21546604c45d36197cc22f6eb173f0c509108ab8bf268d57c

data/CHANGELOG.md

@@ -2,6 +2,16 @@ Do this to generate your change history
 
   git log --pretty=format:'  * %h - %s (%an, %ad)'
 
+### 0.2.3.rc1 (3 Jan 2015)
+
+* afd9cf3 - Removed awesome print gem dependency. (Beth, Sat Jan 3 16:49:40 2015 +1100)
+* 5ae2c12 - Added rake task to package pact-mock-service as a standalone executable using Travelling Ruby. (Beth, Sat Jan 3 16:14:20 2015 +1100)
+* b238f2a - Added message to indicate which part of the interactions differ when an interaction with the same description and provider state, but different request/response is added. https://github.com/realestate-com-au/pact/issues/18 (Beth, Sat Jan 3 14:20:36 2015 +1100)
+* cf38365 - Moved check for 'almost duplicate' interaction to when the interaction is set up. If it occurs during replay, the error does not get shown to the user. https://github.com/bethesque/pact-mock_service/issues/1 (Beth, Sat Jan 3 11:10:47 2015 +1100)
+* 1da9a74 - Added --pact-dir to CLI. Make --pact-dir and --log dir if they do not already exist. (Beth, Sat Jan 3 09:07:03 2015 +1100)
+* 4a2a9a2 - Added handler for SIGTERM to shut down mock service. (Beth, Fri Jan 2 12:07:29 2015 +1100)
+* 57c1a14 - Added support to run the mock service on SSL. Important for browser-based consumers. (Tal Rotbart, Wed Dec 31 09:43:52 2014 +1100)
+
 ### 0.2.2 (29 October 2014)
 
 * 515ed14 - Added feature tests for mock service to show how it should respond under different circumstances. (Beth, Wed Oct 29 09:21:15 2014 +1100)

data/lib/pact/consumer/app_manager.rb

@@ -26,7 +26,7 @@ module Pact
         raise "Currently only http is supported" unless uri.scheme == 'http'
         raise "Currently only services on localhost are supported" unless uri.host == 'localhost'
 
-        register(MockService.new(log_file: create_log_file(name), name: name), uri.port)
+        register(MockService.new(log_file: create_log_file(name), name: name, pact_dir: pact_dir), uri.port)
       end
 
       def register(app, port = FindAPort.available_port)
@@ -67,6 +67,10 @@ module Pact
 
       private
 
+      def pact_dir
+        Pact.configuration.pact_dir
+      end
+
       def create_log_file service_name
         FileUtils::mkdir_p Pact.configuration.log_dir
         log = File.open(log_file_path(service_name), 'w')

data/lib/pact/consumer/interactions_filter.rb

@@ -20,7 +20,6 @@ module Pact
       end
 
       class UpdatableInteractionsFilter < InteractionsFilter
-
          def << interaction
             if (ndx = index_of(interaction))
                @interactions[ndx] = interaction
@@ -28,21 +27,6 @@ module Pact
                @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
+end

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

@@ -0,0 +1,34 @@
+require 'pact/consumer/mock_service/candidate_interactions'
+
+module Pact
+  module Consumer
+    class ActualInteractions
+
+      attr_reader :matched_interactions, :interaction_mismatches, :unexpected_requests
+
+      def initialize
+        clear
+      end
+
+      # For testing, sigh
+      def clear
+        @matched_interactions = []
+        @interaction_mismatches = []
+        @unexpected_requests = []
+      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
+
+    end
+  end
+end

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

@@ -3,9 +3,10 @@ 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/expected_interactions'
+require 'pact/consumer/mock_service/actual_interactions'
+require 'pact/consumer/mock_service/verified_interactions'
 require 'pact/consumer/mock_service/interaction_delete'
 require 'pact/consumer/mock_service/interaction_post'
 require 'pact/consumer/mock_service/interaction_replay'
@@ -28,18 +29,21 @@ module Pact
 
       def initialize options = {}
         log_description = configure_logger options
-        interaction_list = InteractionList.new
 
         @name = options.fetch(:name, "MockService")
-        interactions = []
+        pact_dir = options[:pact_dir]
+        expected_interactions = ExpectedInteractions.new
+        actual_interactions = ActualInteractions.new
+        verified_interactions = VerifiedInteractions.new
+
         @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),
+          MissingInteractionsGet.new(@name, @logger, expected_interactions, actual_interactions),
+          VerificationGet.new(@name, @logger, expected_interactions, actual_interactions, log_description),
+          InteractionPost.new(@name, @logger, expected_interactions, verified_interactions),
+          InteractionDelete.new(@name, @logger, expected_interactions, actual_interactions),
           LogGet.new(@name, @logger),
-          PactPost.new(@name, @logger, interactions),
-          InteractionReplay.new(@name, @logger, interaction_list, interactions)
+          PactPost.new(@name, @logger, verified_interactions, pact_dir),
+          InteractionReplay.new(@name, @logger, expected_interactions, actual_interactions, verified_interactions)
         ]
       end
 
@@ -47,6 +51,7 @@ module Pact
         options = {log_file: $stdout}.merge options
         log_stream = options[:log_file]
         @logger = Logger.new log_stream
+        @logger.formatter = options[:log_formatter] if options[:log_formatter]
         @logger.level = Pact.configuration.logger.level
 
         if log_stream.is_a? File
@@ -64,16 +69,14 @@ module Pact
         response = []
         begin
           relevant_handler = @handlers.detect { |handler| handler.match? env }
-          response = relevant_handler.respond env
+          response = relevant_handler.respond(env)
         rescue StandardError => e
-          @logger.error 'Error ocurred in mock service:'
-          @logger.ap e, :error
-          @logger.ap e.backtrace
+          @logger.error "Error ocurred in mock service: #{e.class} - #{e.message}"
+          @logger.error e.backtrace.join("\n")
           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
+          @logger.error "Exception ocurred in mock service: #{e.class} - #{e.message}"
+          @logger.error e.backtrace.join("\n")
           raise e
         end
         response
@@ -81,4 +84,4 @@ module Pact
 
     end
   end
-end
+end

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

@@ -0,0 +1,13 @@
+module Pact
+  module Consumer
+    class CandidateInteractions < Array
+
+      def matching_interactions actual_request
+        select do | candidate_interaction |
+          candidate_interaction.request.matches? actual_request
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'pact/consumer/mock_service/candidate_interactions'
+
+module Pact
+  module Consumer
+    class ExpectedInteractions < Array
+
+      def find_candidate_interactions actual_request
+        CandidateInteractions.new(
+          select do | interaction |
+            interaction.request.matches_route? actual_request
+          end
+        )
+      end
+
+    end
+  end
+end

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

@@ -8,11 +8,12 @@ module Pact
 
       include RackRequestHelper
 
-      attr_accessor :interaction_list
+      attr_accessor :expected_interactions, :actual_interactions
 
-      def initialize name, logger, interaction_list
+      def initialize name, logger, expected_interactions, actual_interactions
         super name, logger
-        @interaction_list = interaction_list
+        @expected_interactions = expected_interactions
+        @actual_interactions = actual_interactions
       end
 
       def request_path
@@ -24,10 +25,15 @@ module Pact
       end
 
       def respond env
-        interaction_list.clear
-        logger.info "Cleared interactions before example \"#{params_hash(env)['example_description']}\""
+        expected_interactions.clear
+        actual_interactions.clear
+        logger.info "Cleared interactions before example \"#{example_description(env)}\""
         [200, {}, ['Deleted interactions']]
       end
+
+      def example_description env
+        params_hash(env).fetch('example_description', [])[0]
+      end
     end
   end
 end

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

@@ -1,14 +1,15 @@
 require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+require 'pact/mock_service/interaction_decorator'
+require 'pact/shared/json_differ'
 
 module Pact
   module Consumer
     class InteractionPost < MockServiceAdministrationEndpoint
 
-      attr_accessor :interaction_list
-
-      def initialize name, logger, interaction_list
+      def initialize name, logger, expected_interactions, verified_interactions
         super name, logger
-        @interaction_list = interaction_list
+        @expected_interactions = expected_interactions
+        @verified_interactions = verified_interactions
       end
 
       def request_path
@@ -21,12 +22,74 @@ module Pact
 
       def respond env
         request_body = env['rack.input'].string
-        interaction = Interaction.from_hash(JSON.load(request_body))
-        interaction_list.add interaction
+        interaction = Interaction.from_hash(JSON.load(request_body)) # Load creates the Pact::XXX classes
+
+        if (previous_interaction = interaction_already_verified_with_same_description_and_provider_state_but_not_equal(interaction))
+          handle_almost_duplicate_interaction previous_interaction, interaction
+        else
+          add_expected_interaction request_body, interaction
+        end
+      end
+
+      private
+
+      attr_accessor :expected_interactions, :verified_interactions
+
+      def add_expected_interaction request_body, interaction
+        expected_interactions << interaction
         logger.info "Registered expected interaction #{interaction.request.method_and_path}"
         logger.debug JSON.pretty_generate JSON.parse(request_body)
         [200, {}, ['Added interaction']]
       end
+
+      def handle_almost_duplicate_interaction previous_interaction, interaction
+        message = InteractionDiffMessage.new(previous_interaction, interaction).to_s
+        logger.error message
+        [500, {}, [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
+
+      class InteractionDiffMessage
+
+        def initialize previous_interaction, new_interaction
+          @previous_interaction = previous_interaction
+          @new_interaction = new_interaction
+        end
+
+        def to_s
+          "An interaction with same description (#{new_interaction.description.inspect}) and provider state (#{new_interaction.provider_state.inspect}) but a different #{differences} has already been used. Please use a different description or provider state."
+        end
+
+        private
+
+        attr_reader :previous_interaction, :new_interaction
+
+        def differences
+          diff = Pact::JsonDiffer.call(previous_interaction_hash, new_interaction_hash, allow_unexpected_keys: false)
+          diff.keys.collect do | parent_key |
+            diff[parent_key].keys.collect do | child_key |
+              "#{parent_key} #{child_key}"
+            end
+          end.flatten.join(", ").reverse.sub(",", "dna ").reverse
+        end
+
+        def previous_interaction_hash
+          raw_hash previous_interaction
+        end
+
+        def new_interaction_hash
+          raw_hash new_interaction
+        end
+
+        def raw_hash interaction
+          JSON.parse(Pact::MockService::InteractionDecorator.new(interaction).to_json)
+        end
+
+      end
     end
   end
 end

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

@@ -1,25 +1,34 @@
 require 'pact/matchers'
+require 'pact/consumer/request'
 require 'pact/consumer/mock_service/rack_request_helper'
 require 'pact/consumer/mock_service/interaction_mismatch'
 require 'pact/consumer_contract'
-require 'pact/consumer/interactions_filter'
 require 'pact/mock_service/response_decorator'
 require 'pact/mock_service/interaction_decorator'
 
 module Pact
   module Consumer
 
+    module PrettyGenerate
+      #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
+
     class InteractionReplay
       include Pact::Matchers
       include RackRequestHelper
+      include PrettyGenerate
 
-      attr_accessor :name, :logger, :interaction_list, :interactions
+      attr_accessor :name, :logger, :expected_interactions, :actual_interactions, :verified_interactions
 
-      def initialize name, logger, interaction_list, interactions
+      def initialize name, logger, expected_interactions, actual_interactions, verified_interactions
         @name = name
         @logger = logger
-        @interaction_list = interaction_list
-        @interactions = DistinctInteractionsFilter.new(interactions)
+        @expected_interactions = expected_interactions
+        @actual_interactions = actual_interactions
+        @verified_interactions = verified_interactions
       end
 
       def match? env
@@ -32,16 +41,12 @@ module Pact
 
       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 request_hash
-        candidate_interactions = interaction_list.find_candidate_interactions actual_request
-        matching_interactions = find_matching_interactions actual_request, from: candidate_interactions
+        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
@@ -51,50 +56,66 @@ module Pact
         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
+      def handle_matched_interaction interaction
+        HandleMatchedInteraction.call(interaction, verified_interactions, actual_interactions, logger)
       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(Pact::MockService::ResponseDecorator.new(interaction.response))
-        response
+      def handle_more_than_one_matching_interaction actual_request, matching_interactions
+        HandleMultipleInteractionsFound.call(actual_request, matching_interactions, logger)
       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]]
+      def handle_unrecognised_request actual_request, candidate_interactions
+        HandleUnrecognisedInteraction.call(actual_request, candidate_interactions, actual_interactions, logger)
       end
 
-      def handle_more_than_one_matching_interaction actual_request, matching_interactions
+      def logger_info_ap msg
+        logger.info msg
+      end
+
+    end
+
+    class HandleMultipleInteractionsFound
+
+      extend PrettyGenerate
+
+      def self.call actual_request, matching_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
-        multiple_interactions_found_response actual_request, matching_interactions
+        response actual_request, matching_interactions
       end
 
-      def interaction_mismatch actual_request, candidate_interactions
-        InteractionMismatch.new(candidate_interactions, actual_request)
+      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]]
       end
 
-      def request_summary_for interaction
+      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 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 unrecognised_request_response interaction_mismatch
+      def self.response interaction_mismatch
         response = {
           message: "No interaction found for #{interaction_mismatch.actual_request.method_and_path}",
           interaction_diffs:  interaction_mismatch.to_hash
@@ -102,40 +123,39 @@ module Pact
         [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}"
+      def self.interaction_mismatch actual_request, candidate_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
 
-      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
+
+    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 response_from response
+      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 render_body body
+      def self.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

@@ -21,7 +21,7 @@ module Pact
       end
 
       def message env
-        params_hash(env)['msg']
+        params_hash(env).fetch('msg', [])[0]
       end
     end
   end

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

@@ -1,4 +1,5 @@
 require 'pact/consumer/mock_service/mock_service_administration_endpoint'
+require 'pact/consumer/mock_service/verification'
 
 module Pact
   module Consumer
@@ -6,9 +7,10 @@ module Pact
     class MissingInteractionsGet < MockServiceAdministrationEndpoint
       include RackRequestHelper
 
-      def initialize name, logger, interaction_list
+      def initialize name, logger, expected_interactions, actual_interactions
         super name, logger
-        @interaction_list = interaction_list
+        @expected_interactions = expected_interactions
+        @actual_interactions = actual_interactions
       end
 
       def request_path
@@ -20,11 +22,12 @@ module Pact
       end
 
       def respond env
-        number_of_missing_interactions = @interaction_list.missing_interactions.size
+        verification = 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}"
         [200, {}, [{size: number_of_missing_interactions}.to_json]]
       end
 
     end
   end
-end
+end

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

@@ -5,11 +5,12 @@ module Pact
   module Consumer
     class PactPost < MockServiceAdministrationEndpoint
 
-      attr_accessor :consumer_contract, :interactions
+      attr_accessor :consumer_contract, :verified_interactions, :default_options
 
-      def initialize name, logger, interactions
+      def initialize name, logger, verified_interactions, pact_dir
         super name, logger
-        @interactions = interactions
+        @verified_interactions = verified_interactions
+        @default_options = {pact_dir: pact_dir}
       end
 
       def request_path
@@ -23,7 +24,8 @@ module Pact
       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)
+        consumer_contract_params = default_options.merge(consumer_contract_details.merge(interactions: verified_interactions))
+        consumer_contract_writer = ConsumerContractWriter.new(consumer_contract_params, logger)
         json = consumer_contract_writer.write
 
         [200, {'Content-Type' =>'application/json'}, [json]]

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

@@ -10,7 +10,7 @@ module Pact
       }
 
       def params_hash env
-        env["QUERY_STRING"].split("&").collect{| param| param.split("=")}.inject({}){|params, param| params[param.first] = URI.decode(param.last); params }
+        CGI::parse env["QUERY_STRING"]
       end
 
       def request_as_hash_from env