pact-mock_service 0.2.4 → 0.3.0

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

@@ -0,0 +1,41 @@
+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
+          super name, logger
+          @session = session
+        end
+
+        def request_path
+          '/interactions'
+        end
+
+        def request_method
+          'POST'
+        end
+
+        def respond env
+          request_body = env['rack.input'].string
+          interaction = Interaction.from_hash(JSON.load(request_body)) # Load creates the Pact::XXX classes
+
+          begin
+            session.add_expected_interaction interaction
+            [200, {}, ['Set interactions']]
+          rescue AlmostDuplicateInteractionError => e
+            [500, {}, e.message]
+          end
+
+        end
+
+        private
+
+        attr_accessor :session
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+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
+          JSON.pretty_generate(JSON.parse(object.to_json))
+        end
+      end
+
+      class InteractionReplay < BaseRequestHandler
+        include Pact::Matchers
+        include PrettyGenerate
+
+        attr_accessor :name, :logger, :expected_interactions, :actual_interactions, :verified_interactions
+
+        def initialize name, logger, session, cors_enabled=false
+          @name = name
+          @logger = logger
+          @expected_interactions = session.expected_interactions
+          @actual_interactions = session.actual_interactions
+          @verified_interactions = session.verified_interactions
+          @cors_enabled = cors_enabled
+        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
+          HandleMultipleInteractionsFound.call(actual_request, matching_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, 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]]
+        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 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]]
+        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 '' unless body
+          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,42 @@
+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
+          super name, logger
+          @session = session
+        end
+
+        def request_path
+          '/interactions'
+        end
+
+        def request_method
+          'PUT'
+        end
+
+        def respond env
+          request_body = JSON.load(env['rack.input'].string)
+          interactions = request_body['interactions'].collect { | hash | Interaction.from_hash(hash) }
+          begin
+            session.set_expected_interactions interactions
+            [200, {}, ['Set interactions']]
+          rescue AlmostDuplicateInteractionError => e
+            [500, {}, e.message]
+          end
+        end
+
+        private
+
+        attr_accessor :session
+
+      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)}"
+          [200, {}, []]
+        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}"
+          [200, {}, [{size: number_of_missing_interactions}.to_json]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'pact/mock_service/request_handlers/base_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      class Options < BaseRequestHandler
+
+        attr_reader :name, :logger, :cors_enabled
+
+        def initialize name, logger, cors_enabled
+          @name = name
+          @logger = logger
+          @cors_enabled = cors_enabled
+        end
+
+        def match? env
+           is_options_request?(env) && (cors_enabled || is_administration_request?(env))
+        end
+
+        def respond env
+          cors_headers = {
+           'Access-Control-Allow-Origin' => env.fetch('HTTP_ORIGIN','*'),
+           'Access-Control-Allow-Headers' => headers_from(env)["Access-Control-Request-Headers"],
+           'Access-Control-Allow-Methods' => 'DELETE, POST, GET, HEAD, PUT, TRACE, CONNECT'
+          }
+          logger.info "Received OPTIONS request for mock service administration endpoint #{env['HTTP_ACCESS_CONTROL_REQUEST_METHOD']} #{env['PATH_INFO']}. Returning CORS headers: #{cors_headers.to_json}."
+          [200, cors_headers, []]
+        end
+
+        def is_options_request? env
+          env['REQUEST_METHOD'] == 'OPTIONS'
+        end
+
+        def is_administration_request? env
+          env["HTTP_ACCESS_CONTROL_REQUEST_HEADERS"].match(/x-pact-mock-service/i)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+require 'pact/consumer_contract/consumer_contract_writer'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class PactPost < BaseAdministrationRequestHandler
+
+        attr_accessor :consumer_contract, :verified_interactions, :default_options
+
+        def initialize name, logger, session
+          super name, logger
+          @verified_interactions = session.verified_interactions
+          @default_options = {}
+          @default_options.merge!(session.consumer_contract_details)
+        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_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]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'pact/mock_service/request_handlers/base_administration_request_handler'
+
+module Pact
+  module MockService
+    module RequestHandlers
+      class VerificationGet < BaseAdministrationRequestHandler
+
+        def initialize name, logger, session
+          super name, logger
+          @expected_interactions = session.expected_interactions
+          @actual_interactions = session.actual_interactions
+        end
+
+        def request_path
+          '/interactions/verification'
+        end
+
+        def request_method
+          'GET'
+        end
+
+        def respond env
+          verification = Pact::MockService::Interactions::Verification.new(expected_interactions, actual_interactions)
+          if verification.all_matched?
+            logger.info "Verifying - interactions matched for example \"#{example_description(env)}\""
+            [200, {'Content-Type' => 'text/plain'}, ['Interactions matched']]
+          else
+            error_message = FailureMessage.new(verification).to_s
+            logger.warn "Verifying - actual interactions do not match expected interactions for example \"#{example_description(env)}\". \n#{error_message}"
+            logger.warn error_message
+            [500, {'Content-Type' => 'text/plain'}, ["Actual interactions do not match expected interactions for mock #{name}.\n\n#{error_message}See #{logger.description} for details."]]
+          end
+        end
+
+        private
+
+        attr_accessor :expected_interactions, :actual_interactions
+
+        def example_description env
+          params_hash(env).fetch("example_description", [])[0]
+        end
+
+        class FailureMessage
+
+          def initialize verification
+            @verification = verification
+          end
+
+          def to_s
+            titles_and_summaries.collect do | title, summaries |
+              "#{title}:\n\t#{summaries.join("\n\t")}\n\n" if summaries.any?
+            end.compact.join
+
+          end
+
+          private
+
+          attr_reader :verification
+
+          def titles_and_summaries
+            {
+              "Incorrect requests" => verification.interaction_mismatches_summaries,
+              "Missing requests" => verification.missing_interactions_summaries,
+              "Unexpected requests" => verification.unexpected_requests_summaries,
+            }
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/request_handlers.rb

@@ -0,0 +1,40 @@
+require 'pact/mock_service/request_handlers/interaction_post'
+require 'pact/mock_service/request_handlers/interactions_put'
+require 'pact/mock_service/request_handlers/index_get'
+require 'pact/mock_service/request_handlers/interaction_delete'
+require 'pact/mock_service/request_handlers/interaction_replay'
+require 'pact/mock_service/request_handlers/log_get'
+require 'pact/mock_service/request_handlers/options'
+require 'pact/mock_service/request_handlers/missing_interactions_get'
+require 'pact/mock_service/request_handlers/pact_post'
+require 'pact/mock_service/request_handlers/verification_get'
+require 'pact/consumer/request'
+require 'pact/support'
+
+module Pact
+  module MockService
+    module RequestHandlers
+
+      def self.new *args
+        App.new(*args)
+      end
+
+      class App < ::Rack::Cascade
+        def initialize name, logger, session, options
+          super [
+            Options.new(name, logger, options[:cors_enabled]),
+            MissingInteractionsGet.new(name, logger, session),
+            VerificationGet.new(name, logger, session),
+            InteractionPost.new(name, logger, session),
+            InteractionsPut.new(name, logger, session),
+            InteractionDelete.new(name, logger, session),
+            LogGet.new(name, logger),
+            PactPost.new(name, logger, session),
+            IndexGet.new(name, logger),
+            InteractionReplay.new(name, logger, session, options[:cors_enabled])
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/run.rb

@@ -1,5 +1,6 @@
 require 'find_a_port'
-require 'pact/consumer/mock_service'
+require 'pact/mock_service/app'
+require 'pact/consumer/mock_service/set_location'
 
 module Pact
   module MockService
@@ -14,7 +15,7 @@ module Pact
       end
 
       def call
-        require 'pact/consumer/mock_service'
+        require 'pact/mock_service/app'
 
         trap(:INT) { call_shutdown_hooks  }
         trap(:TERM) { call_shutdown_hooks }
@@ -28,7 +29,8 @@ module Pact
 
       def mock_service
         @mock_service ||= begin
-          Pact::Consumer::MockService.new(service_options)
+          mock_service = Pact::MockService.new(service_options)
+          Pact::Consumer::SetLocation.new(mock_service, base_url)
         end
       end
 
@@ -63,7 +65,7 @@ module Pact
 
       def webbrick_opts
         opts = {
-          :Port => options[:port] || FindAPort.available_port,
+          :Port => port,
           :AccessLog => []
         }
         opts.merge!(ssl_opts) if options[:ssl]
@@ -76,6 +78,14 @@ module Pact
           :SSLCertName => [ %w[CN localhost] ]
         }
       end
+
+      def port
+        @port ||= options[:port] || FindAPort.available_port
+      end
+
+      def base_url
+        options[:ssl] ? "https://localhost:#{port}" : "http://localhost:#{port}"
+      end
     end
   end
 end

data/lib/pact/mock_service/session.rb

@@ -0,0 +1,70 @@
+require 'pact/mock_service/interactions/expected_interactions'
+require 'pact/mock_service/interactions/actual_interactions'
+require 'pact/mock_service/interactions/verified_interactions'
+require 'pact/mock_service/interaction_decorator'
+require 'pact/mock_service/interactions/interaction_diff_message'
+
+module Pact
+  module MockService
+
+    class AlmostDuplicateInteractionError < StandardError; end
+
+    class Session
+
+      attr_reader :expected_interactions, :actual_interactions, :verified_interactions, :consumer_contract_details, :logger
+
+      def initialize options
+        @logger = options[:logger]
+        @expected_interactions = Interactions::ExpectedInteractions.new
+        @actual_interactions = Interactions::ActualInteractions.new
+        @verified_interactions = Interactions::VerifiedInteractions.new
+        @consumer_contract_details = {
+          pact_dir: options[:pact_dir],
+          consumer: {name: options[:consumer]},
+          provider: {name: options[:provider]},
+          interactions: verified_interactions
+        }
+      end
+
+      def set_expected_interactions interactions
+        clear_expected_and_actual_interactions
+        interactions.each do | interaction |
+          add_expected_interaction interaction
+        end
+      end
+
+      def clear_expected_and_actual_interactions
+        expected_interactions.clear
+        actual_interactions.clear
+      end
+
+      def add_expected_interaction interaction
+        if (previous_interaction = interaction_already_verified_with_same_description_and_provider_state_but_not_equal(interaction))
+          handle_almost_duplicate_interaction previous_interaction, interaction
+        else
+          really_add_expected_interaction interaction
+        end
+      end
+
+      private
+
+      def really_add_expected_interaction interaction
+        expected_interactions << interaction
+        logger.info "Registered expected interaction #{interaction.request.method_and_path}"
+        logger.debug JSON.pretty_generate InteractionDecorator.new(interaction)
+      end
+
+      def handle_almost_duplicate_interaction previous_interaction, interaction
+        message = Interactions::InteractionDiffMessage.new(previous_interaction, interaction).to_s
+        logger.error message
+        raise AlmostDuplicateInteractionError, 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
+
+    end
+  end
+end