hs-pact-mock_service 3.9.2

data/lib/pact/mock_service/client.rb

@@ -0,0 +1,79 @@
+require 'net/http'
+require 'pact/mock_service/interaction_decorator'
+require 'pact/errors'
+
+module Pact
+  module MockService
+
+    class VerificationFailedError < Pact::Error; end
+    class AddInteractionError < Pact::Error; end
+    class WritePactError < Pact::Error; end
+
+    class Client
+
+      MOCK_SERVICE_ADMINISTRATON_HEADERS = {'X-Pact-Mock-Service' => 'true'}
+
+      def initialize port, host = 'localhost'
+        @http = Net::HTTP.new(host, port)
+      end
+
+      def verify example_description
+        response = http.request_get("/interactions/verification?example_description=#{CGI.escape(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+        raise VerificationFailedError.new("\e[31m#{response.body}\e[m") unless response.is_a? Net::HTTPSuccess
+      end
+
+      def log msg
+        http.request_get("/log?msg=#{CGI.escape(msg)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def wait_for_interactions wait_max_seconds, poll_interval
+        wait_until_true(wait_max_seconds, poll_interval) do
+          response = http.request_get("/interactions/missing", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+          JSON.parse(response.body)['size'] == 0
+        end
+      end
+
+      def clear_interactions example_description
+        http.delete("/interactions?example_description=#{CGI.escape(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def add_expected_interaction interaction
+        response = http.request_post(
+          '/interactions',
+          interaction_json(interaction),
+          MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json")
+        )
+        raise AddInteractionError.new("\e[31m#{response.body}\e[m") unless response.is_a? Net::HTTPSuccess
+      end
+
+      def self.clear_interactions mock_service_base_url, example_description
+        uri = URI(mock_service_base_url)
+        Net::HTTP.new(uri.host, uri.port).delete("/interactions?example_description=#{CGI.escape(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def write_pact pacticipant_details
+        response = http.request_post("/pact", pacticipant_details.to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
+        raise WritePactError.new("\e[31m#{response.body}\e[m") unless response.is_a? Net::HTTPSuccess
+        response.body
+      end
+
+      private
+
+      attr_reader :http
+
+      #todo: in need a better home (where can we move it?)
+      def wait_until_true timeout=3, interval=0.1
+        time_limit = Time.now + timeout
+        loop do
+          result =  yield
+          return if result || Time.now >= time_limit
+          sleep interval
+        end
+      end
+
+      def interaction_json interaction
+        Pact::MockService::InteractionDecorator.new(interaction).to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'pact/consumer/mock_service/rack_request_helper'
+require 'pact/mock_service/control_server/require_pacticipant_headers'
+require 'pact/mock_service/control_server/index'
+require 'pact/mock_service/control_server/mock_services'
+require 'pact/mock_service/control_server/mock_service_creator'
+require 'rack'
+require 'rack/cascade'
+
+module Pact
+  module MockService
+    module ControlServer
+      class App
+
+        include Pact::Consumer::RackRequestHelper
+
+        def initialize options = {}
+          @mock_services = mock_services = MockServices.new([])
+          @app = Rack::Builder.new {
+            run Rack::Cascade.new([
+              Index.new,
+              Rack::Builder.new {
+                use RequirePacticipantHeaders
+                run Rack::Cascade.new([
+                  mock_services,
+                  MockServiceCreator.new(mock_services, options)
+                ])
+              }
+            ])
+          }
+        end
+
+        def call env
+          @app.call(env)
+        end
+
+        def shutdown
+          @mock_services.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/delegator.rb

@@ -0,0 +1,44 @@
+# Delegates the incoming request that was sent to the control server
+# to the underlying MockService
+# if the X-Pact-Consumer and X-Pact-Provider headers match
+# the consumer and provider for this MockService.
+
+module Pact
+  module MockService
+    module ControlServer
+
+      class Delegator
+
+        HTTP_X_PACT_CONSUMER = 'HTTP_X_PACT_CONSUMER'.freeze
+        HTTP_X_PACT_PROVIDER = 'HTTP_X_PACT_PROVIDER'.freeze
+        PACT_MOCK_SERVICE_HEADER = {'HTTP_X_PACT_MOCK_SERVICE' => 'true'}.freeze
+        NOT_FOUND_RESPONSE = [404, {}, []].freeze
+
+        def initialize app, consumer_name, provider_name
+          @app = app
+          @consumer_name = consumer_name
+          @provider_name = provider_name
+        end
+
+        def call env
+          return NOT_FOUND_RESPONSE unless consumer_and_provider_headers_match?(env)
+          delegate env
+        end
+
+        def shutdown
+          @app.shutdown
+        end
+
+        private
+
+        def consumer_and_provider_headers_match? env
+          env[HTTP_X_PACT_CONSUMER] == @consumer_name && env[HTTP_X_PACT_PROVIDER] == @provider_name
+        end
+
+        def delegate env
+          @app.call(env.merge(PACT_MOCK_SERVICE_HEADER))
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/index.rb

@@ -0,0 +1,25 @@
+module Pact
+  module MockService
+    module ControlServer
+      class Index
+
+        HTTP_X_PACT_MOCK_SERVICE = 'HTTP_X_PACT_MOCK_SERVICE'
+        PATH_INFO = 'PATH_INFO'
+        INDEX_RESPONSE = [200, {'Content-Type' => 'text/plain'}, ['Control server running']].freeze
+        NOT_FOUND_RESPONSE = [404, {}, []].freeze
+
+        def call env
+          if is_index_request_with_mock_service_header? env
+            INDEX_RESPONSE
+          else
+            NOT_FOUND_RESPONSE
+          end
+        end
+
+        def is_index_request_with_mock_service_header? env
+          env[HTTP_X_PACT_MOCK_SERVICE] && env[PATH_INFO].chomp("/").size == 0
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/mock_service_creator.rb

@@ -0,0 +1,32 @@
+require 'pact/mock_service/spawn'
+require 'pact/mock_service/control_server/delegator'
+require 'find_a_port'
+require 'pact/mock_service/server/wait_for_server_up'
+
+# Create a new MockService on a random port and delegate the incoming request to it
+
+module Pact
+  module MockService
+    module ControlServer
+      class MockServiceCreator
+
+        attr_reader :options
+
+        def initialize mock_services, options
+          @mock_services = mock_services
+          @options = options
+        end
+
+        def call env
+          consumer_name = env['HTTP_X_PACT_CONSUMER']
+          provider_name = env['HTTP_X_PACT_PROVIDER']
+          port = FindAPort.available_port
+          mock_service = Pact::MockService::Spawn.(consumer_name, provider_name, options[:host] || 'localhost', port, options)
+          delegator = Delegator.new(mock_service, consumer_name, provider_name)
+          @mock_services.add(delegator)
+          delegator.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/mock_services.rb

@@ -0,0 +1,26 @@
+require 'rack'
+require 'rack/cascade'
+
+module Pact
+  module MockService
+    module ControlServer
+      class MockServices < Rack::Cascade
+
+        def add app
+          mock_services << app
+          super
+        end
+
+        def shutdown
+          mock_services.each(&:shutdown)
+        end
+
+        private
+
+        def mock_services
+          @mock_services ||= []
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/require_pacticipant_headers.rb

@@ -0,0 +1,20 @@
+module Pact
+  module MockService
+    module ControlServer
+      class RequirePacticipantHeaders
+
+        def initialize app
+          @app = app
+        end
+
+        def call env
+          if env['HTTP_X_PACT_CONSUMER'] && env['HTTP_X_PACT_PROVIDER']
+            @app.call(env)
+          else
+            [500, {}, ["Please specify the consumer name and the provider name by setting the X-Pact-Consumer and X-Pact-Provider headers"]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/control_server/run.rb

@@ -0,0 +1,73 @@
+require 'pact/mock_service/control_server/app'
+require 'pact/mock_service/server/webrick_request_monkeypatch'
+
+module Pact
+  module MockService
+    module ControlServer
+      class Run
+
+        def self.call options
+          new(options).call
+        end
+
+        def initialize options
+          @options = options
+        end
+
+        def call
+          trap(:INT) { shutdown }
+          trap(:TERM) { shutdown }
+
+          # https://github.com/rack/rack/blob/ae78184e5c1fcf4ac133171ed4b47b0548cd9b44/lib/rack/handler/webrick.rb#L32
+          # Rack adapter for webrick uses class variable for the server which contains the port,
+          # so if we use it more than once in the same process, we lose the reference to the first
+          # server, and can't shut it down. So, keep a manual reference to the Webrick server, and
+          # shut it down directly rather than use Rack::Handler::WEBrick.shutdown
+          # Ruby!
+          Rack::Handler::WEBrick.run(control_server, **webbrick_opts) do | server |
+            @webrick_server = server
+          end
+        end
+
+        private
+
+        attr_reader :options
+
+        def control_server
+          @control_server ||= Pact::MockService::ControlServer::App.new control_server_options
+        end
+
+        def shutdown
+          unless @shutting_down
+            @shutting_down = true
+            begin
+              @control_server.shutdown
+            ensure
+              @webrick_server.shutdown
+            end
+          end
+        end
+
+        def control_server_options
+          {
+            log_dir: options[:log_dir] || "log",
+            pact_dir: options[:pact_dir] || ".",
+            unique_pact_file_names: options[:unique_pact_file_names],
+            cors_enabled: options[:cors] || false,
+            ssl: options[:ssl],
+            host: options[:host],
+            pact_specification_version: options[:pact_specification_version]
+          }
+        end
+
+        def webbrick_opts
+          {
+            :Port => options[:port],
+            :Host => options[:host],
+            :AccessLog => []
+          }
+        end
+      end
+    end
+  end
+end

data/lib/pact/mock_service/errors.rb

@@ -0,0 +1,9 @@
+require 'pact/errors'
+
+module Pact
+  module MockService
+    class AlmostDuplicateInteractionError < Pact::Error; end
+
+    class SameSameButDifferentError < ::Pact::Error; end
+  end
+end

data/lib/pact/mock_service/interaction_decorator.rb

@@ -0,0 +1,49 @@
+require 'pact/shared/active_support_support'
+require 'pact/mock_service/request_decorator'
+require 'pact/mock_service/response_decorator'
+
+# 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 MockService
+    class InteractionDecorator
+
+      include ActiveSupportSupport
+
+      def initialize interaction
+        @interaction = interaction
+      end
+
+      def as_json options = {}
+        fix_all_the_things to_hash
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      end
+
+      def to_hash
+        hash = { :description => interaction.description }
+        hash[:providerState] = interaction.provider_state if interaction.provider_state
+        hash[:request] = decorate_request.as_json
+        hash[:response] = decorate_response.as_json
+        hash[:metadata] = interaction.metadata
+        hash
+      end
+
+      private
+
+      attr_reader :interaction
+
+      def decorate_request
+        RequestDecorator.new(interaction.request)
+      end
+
+      def decorate_response
+        ResponseDecorator.new(interaction.response)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'pact/mock_service/interactions/candidate_interactions'
+
+module Pact
+  module MockService
+    module Interactions
+      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
+end

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

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

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

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

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

@@ -0,0 +1,45 @@
+require 'pact/shared/json_differ'
+require 'pact/mock_service/interaction_decorator'
+
+module Pact
+  module MockService
+    module Interactions
+      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, or remove any random data in the interaction."
+        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/mock_service/interactions/interaction_mismatch.rb

@@ -0,0 +1,74 @@
+module Pact
+  module MockService
+    module Interactions
+
+      # 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
+end

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

@@ -0,0 +1,66 @@
+require 'pact/mock_service/errors'
+require 'pact/mock_service/interactions/interaction_diff_message'
+
+#
+# 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.
+# When running in pactfile_write_mode :merge, an interaction with the same description and provider
+# state must be identical to the existing one, otherwise an exception will be raised.
+
+module Pact
+  module MockService
+    module Interactions
+
+      def self.filter existing_interactions, pactfile_write_mode
+        if pactfile_write_mode == :update
+          UpdatableInteractionsFilter.new(existing_interactions)
+        elsif pactfile_write_mode == :merge
+          MergingInteractionsFilter.new(existing_interactions)
+        else
+          existing_interactions
+        end
+      end
+
+      #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 MergingInteractionsFilter < InteractionsFilter
+        def << interaction
+          if (ndx = index_of(interaction))
+            if same_same_but_different?(@interactions[ndx], interaction)
+              message = Interactions::InteractionDiffMessage.new(@interactions[ndx], interaction).to_s
+              raise SameSameButDifferentError, message
+            end
+            @interactions[ndx] = interaction
+          else
+            @interactions << interaction
+          end
+        end
+
+        def same_same_but_different?(existing_interaction, new_interaction)
+          existing_interaction != new_interaction
+        end
+      end
+    end
+  end
+end