pact-mock_service 0.2.4 → 0.3.0

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

@@ -1,162 +0,0 @@
-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/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, :expected_interactions, :actual_interactions, :verified_interactions
-
-      def initialize name, logger, expected_interactions, actual_interactions, verified_interactions, cors_enabled=false
-        @name = name
-        @logger = logger
-        @expected_interactions = expected_interactions
-        @actual_interactions = actual_interactions
-        @verified_interactions = 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 = 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
-        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

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).fetch('msg', [])[0]
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'pact/consumer/mock_service/mock_service_administration_endpoint'
-require 'pact/consumer/mock_service/verification'
-
-module Pact
-  module Consumer
-
-    class MissingInteractionsGet < MockServiceAdministrationEndpoint
-      include RackRequestHelper
-
-      def initialize name, logger, expected_interactions, actual_interactions
-        super name, logger
-        @expected_interactions = expected_interactions
-        @actual_interactions = actual_interactions
-      end
-
-      def request_path
-        '/interactions/missing'
-      end
-
-      def request_method
-        'GET'
-      end
-
-      def respond env
-        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

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

@@ -1,40 +0,0 @@
-require 'pact/consumer/mock_service/rack_request_helper'
-module Pact
-  module Consumer
-    class MockServiceAdministrationEndpoint
-
-      include RackRequestHelper
-
-      attr_accessor :logger, :name
-
-      def initialize name, logger
-        @name = name
-        @logger = logger
-      end
-
-      def match? env
-        has_mock_service_header?(env) && path_matches?(env) && method_matches?(env)
-      end
-
-      def has_mock_service_header? env
-        env['HTTP_X_PACT_MOCK_SERVICE']
-      end
-
-      def path_matches? env
-        env['PATH_INFO'].chomp("/") == request_path
-      end
-
-      def method_matches? env
-        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/options.rb

@@ -1,43 +0,0 @@
-require 'pact/consumer/mock_service/rack_request_helper'
-require 'pact/consumer/mock_service/mock_service_administration_endpoint'
-
-module Pact
-  module Consumer
-
-    class Options
-
-      include RackRequestHelper
-
-      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

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

@@ -1,38 +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, :verified_interactions, :default_options
-
-      def initialize name, logger, verified_interactions, pact_dir, consumer_contract_details
-        super name, logger
-        @verified_interactions = verified_interactions
-        @default_options = {pact_dir: pact_dir}
-        if consumer_contract_details
-          @default_options.merge!(consumer_contract_details)
-        end
-      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

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

@@ -1,41 +0,0 @@
-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'
-require 'pact/consumer/mock_service/missing_interactions_get'
-require 'pact/consumer/mock_service/verification_get'
-require 'pact/consumer/mock_service/log_get'
-require 'pact/consumer/mock_service/pact_post'
-require 'pact/consumer/mock_service/index_get'
-require 'pact/consumer/mock_service/options'
-require 'pact/consumer/request'
-require 'pact/support'
-
-module Pact
-  module Consumer
-    class MockService
-      class RequestHandlers
-        def initialize name, logger, expected_interactions, actual_interactions, verified_interactions, options
-          @handlers = [
-            Options.new(name, logger, options[:cors_enabled]),
-            MissingInteractionsGet.new(name, logger, expected_interactions, actual_interactions),
-            VerificationGet.new(name, logger, expected_interactions, actual_interactions, options[: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, verified_interactions, options[:pact_dir], options[:consumer_contract_details]),
-            IndexGet.new(name, logger),
-            InteractionReplay.new(name, logger, expected_interactions, actual_interactions, verified_interactions, options[:cors_enabled])
-          ]
-        end
-
-        def call env
-          relevant_handler = @handlers.detect { |handler| handler.match? env }
-          response = relevant_handler.respond(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-module Pact
-  module Consumer
-    class Verification
-
-      def initialize expected_interactions, actual_interactions
-        @expected_interactions = expected_interactions
-        @actual_interactions = actual_interactions
-      end
-
-      def all_matched?
-        interaction_diffs.empty?
-      end
-
-      def interaction_diffs
-        {
-          :missing_interactions => missing_interactions_summaries,
-          :interaction_mismatches => interaction_mismatches_summaries,
-          :unexpected_requests => unexpected_requests_summaries
-        }.each_with_object({}) do | (key, value), hash |
-          hash[key] = value if value.any?
-        end
-      end
-
-      def missing_interactions_summaries
-        missing_interactions.collect(&:request).collect(&:method_and_path)
-      end
-
-      def interaction_mismatches_summaries
-        actual_interactions.interaction_mismatches.collect(&:short_summary)
-      end
-
-      def unexpected_requests_summaries
-        actual_interactions.unexpected_requests.collect(&:method_and_path)
-      end
-
-      def missing_interactions
-        expected_interactions - actual_interactions.matched_interactions - @actual_interactions.interaction_mismatches.collect(&:candidate_interactions).flatten
-      end
-
-      private
-
-      attr_reader :expected_interactions, :actual_interactions
-
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-require 'pact/consumer/mock_service/mock_service_administration_endpoint'
-
-module Pact
-  module Consumer
-    class VerificationGet < MockServiceAdministrationEndpoint
-
-      include RackRequestHelper
-
-      def initialize name, logger, expected_interactions, actual_interactions, log_description
-        super name, logger
-        @expected_interactions = expected_interactions
-        @actual_interactions = actual_interactions
-        @log_description = log_description
-      end
-
-      def request_path
-        '/interactions/verification'
-      end
-
-      def request_method
-        'GET'
-      end
-
-      def respond env
-        verification = 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 #{log_description} for details."]]
-        end
-      end
-
-      private
-
-      attr_accessor :expected_interactions, :actual_interactions, :log_description
-
-      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

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

@@ -1,18 +0,0 @@
-module Pact
-  module Consumer
-    class VerifiedInteractions < Array
-
-      def << interaction
-        unless find_matching_description_and_provider_state interaction
-          super
-        end
-      end
-
-      def find_matching_description_and_provider_state interaction
-        find do |candidate_interaction|
-          candidate_interaction.matches_criteria?(description: interaction.description, provider_state: interaction.provider_state)
-        end
-      end
-    end
-  end
-end

data/lib/pact/consumer/mock_service.rb

@@ -1,43 +0,0 @@
-require 'pact/consumer/mock_service/app'
-require 'pact/consumer/mock_service/error_handler'
-
-module Pact
-  module Consumer
-
-    class MockService
-
-      def initialize options = {}
-        logger, log_description = configure_logger(options)
-        app_options = options.merge(logger: logger, log_description: log_description)
-        @app = Rack::Builder.app do
-          use ErrorHandler, logger
-          use CorsOriginHeaderMiddleware, options[:cors_enabled]
-          run App.new(app_options)
-        end
-      end
-
-      def call env
-        @app.call env
-      end
-
-      def shutdown
-        @app.shutdown
-      end
-
-      def configure_logger options
-        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
-
-        log_description = if log_stream.is_a? File
-           File.absolute_path(log_stream).gsub(Dir.pwd + "/", '')
-        else
-          "standard out/err"
-        end
-        return logger, log_description
-      end
-    end
-  end
-end