pact 1.3.3 → 1.4.0.rc2

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

@@ -1,31 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

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

@@ -1,68 +0,0 @@
-require 'pact/consumer/mock_service/mock_service_administration_endpoint'
-
-module Pact
-  module Consumer
-    class VerificationGet < MockServiceAdministrationEndpoint
-
-      include RackRequestHelper
-      attr_accessor :interaction_list, :log_description
-
-      def initialize name, logger, interaction_list, log_description
-        super name, logger
-        @interaction_list = interaction_list
-        @log_description = log_description
-      end
-
-      def request_path
-        '/interactions/verification'
-      end
-
-      def request_method
-        'GET'
-      end
-
-      def respond env
-        if interaction_list.all_matched?
-          logger.info "Verifying - interactions matched for example \"#{example_description(env)}\""
-          [200, {'Content-Type' => 'text/plain'}, ['Interactions matched']]
-        else
-          error_message = FailureMessage.new(interaction_list).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 #{log_description} for details."]]
-        end
-      end
-
-      def example_description env
-        params_hash(env)['example_description']
-      end
-
-      class FailureMessage
-
-        def initialize interaction_list
-          @interaction_list = interaction_list
-        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 :interaction_list
-
-        def titles_and_summaries
-          {
-            "Incorrect requests" => interaction_list.interaction_mismatches_summaries,
-            "Missing requests" => interaction_list.missing_interactions_summaries,
-            "Unexpected requests" => interaction_list.unexpected_requests_summaries,
-          }
-        end
-
-      end
-    end
-  end
-end

data/lib/pact/consumer/mock_service_client.rb

@@ -1,65 +0,0 @@
-require 'net/http'
-require 'pact/consumer/mock_service_interaction_expectation'
-
-module Pact
-  module Consumer
-    class MockServiceClient
-
-      MOCK_SERVICE_ADMINISTRATON_HEADERS = {'X-Pact-Mock-Service' => 'true'}
-
-      def initialize port
-        @http = Net::HTTP.new('localhost', port)
-      end
-
-      def verify example_description
-        response = http.request_get("/interactions/verification?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
-        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
-      end
-
-      def log msg
-        http.request_get("/log?msg=#{URI.encode(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=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
-      end
-
-      def add_expected_interaction interaction
-        response = http.request_post('/interactions', MockServiceInteractionExpectation.new(interaction).to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
-        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
-      end
-
-      def self.clear_interactions port, example_description
-        Net::HTTP.new("localhost", port).delete("/interactions?example_description=#{URI.encode(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 "\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
-
-    end
-  end
-end