pact 1.3.3 → 1.4.0

data/lib/pact/consumer/app_manager.rb

@@ -1,158 +0,0 @@
-require 'thwait'
-
-require 'net/http'
-require 'uri'
-require 'find_a_port'
-require 'pact/logging'
-require 'pact/consumer/server'
-require 'singleton'
-
-module Pact
-  module Consumer
-    class AppManager
-
-      include Pact::Logging
-
-      include Singleton
-
-      def initialize
-        @apps_spawned = false
-        @app_registrations = []
-      end
-
-      def register_mock_service_for name, url
-        uri = URI(url)
-        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)
-      end
-
-      def register(app, port = FindAPort.available_port)
-        existing = existing_app_on_port port
-        raise "Port #{port} is already being used by #{existing}" if existing and not existing == app
-        app_registration = register_app app, port
-        app_registration.spawn if @apps_spawned
-        port
-      end
-
-      def existing_app_on_port port
-        app_registration = @app_registrations.find { |app_registration| app_registration.port == port }
-        app_registration ? app_registration.app : nil
-      end
-
-      def app_registered_on?(port)
-        app_registrations.any? { |app_registration| app_registration.port == port }
-      end
-
-      def ports_of_mock_services
-        app_registrations.find_all(&:is_a_mock_service?).collect(&:port)
-      end
-
-      def kill_all
-        app_registrations.find_all(&:spawned?).collect(&:kill)
-        @apps_spawned = false
-      end
-
-      def clear_all
-        kill_all
-        @app_registrations = []
-      end
-
-      def spawn_all
-        app_registrations.find_all(&:not_spawned?).collect(&:spawn)
-        @apps_spawned = true
-      end
-
-      private
-
-      def create_log_file service_name
-        FileUtils::mkdir_p Pact.configuration.log_dir
-        log = File.open(log_file_path(service_name), 'w')
-        log.sync = true
-        log
-      end
-
-      def log_file_path service_name
-        File.join(Pact.configuration.log_dir, "#{log_file_name(service_name)}.log")
-      end
-
-      def log_file_name service_name
-        lower_case_name = service_name.downcase.gsub(/\s+/, '_')
-        if lower_case_name.include?('_service')
-          lower_case_name.gsub('_service', '_mock_service')
-        else
-          lower_case_name + '_mock_service'
-        end
-      end
-
-      def app_registrations
-        @app_registrations
-      end
-
-      def register_app app, port
-        app_registration = AppRegistration.new :app => app, :port => port
-        app_registrations << app_registration
-        app_registration
-      end
-    end
-
-    class AppRegistration
-      include Pact::Logging
-      attr_accessor :port
-      attr_accessor :app
-      attr_accessor :pid
-
-      def initialize opts
-        @max_wait = 10
-        @port = opts[:port]
-        @pid = opts[:pid]
-        @app = opts[:app]
-      end
-
-      def kill
-        # TODO: need to work out how to kill
-        # logger.info "Killing #{self}"
-        # Process.kill(9, pid)
-        # Process.wait(pid)
-        # self.pid = nil
-        self.pid = nil
-      end
-
-      def not_spawned?
-        !spawned?
-      end
-
-      def spawned?
-        self.pid != nil
-      end
-
-      def is_a_mock_service?
-        app.is_a? MockService
-      end
-
-      def to_s
-        "#{app} on port #{port}" + (@pid ? " with pid #{pid}" : "")
-      end
-
-      def spawn
-        logger.info "Starting app #{self}..."
-        Pact::Server.new(app, port).boot
-        self.pid = 'unknown'
-        logger.info "Started with pid #{pid}"
-      end
-
-      def wait_until
-        waited = 0
-        wait_time = 0.1
-        while waited < @max_wait do
-          break if yield
-          sleep wait_time
-          waited += wait_time
-          raise "Waited longer than #{@max_wait} seconds" if waited >= @max_wait
-        end
-      end
-
-    end
-  end
-end

data/lib/pact/consumer/interactions_filter.rb

@@ -1,48 +0,0 @@
-#
-# 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.
-#
-
-module Pact
-   module Consumer
-
-      #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 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

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

@@ -1,82 +0,0 @@
-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/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'
-
-AwesomePrint.defaults = {
-  indent: -2,
-  plain: true,
-  index: false
-}
-
-module Pact
-  module Consumer
-
-    class MockService
-
-      def initialize options = {}
-        log_description = configure_logger options
-        interaction_list = InteractionList.new
-
-        @name = options.fetch(:name, "MockService")
-        interactions = []
-        @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),
-          LogGet.new(@name, @logger),
-          PactPost.new(@name, @logger, interactions),
-          InteractionReplay.new(@name, @logger, interaction_list, interactions)
-        ]
-      end
-
-      def configure_logger options
-        options = {log_file: $stdout}.merge options
-        log_stream = options[:log_file]
-        @logger = Logger.new log_stream
-        @logger.level = Pact.configuration.logger.level
-
-        if log_stream.is_a? File
-           File.absolute_path(log_stream).gsub(Dir.pwd + "/", '')
-        else
-          "standard out/err"
-        end
-      end
-
-      def to_s
-        "#{@name} #{super.to_s}"
-      end
-
-      def call env
-        response = []
-        begin
-          relevant_handler = @handlers.detect { |handler| handler.match? env }
-          response = relevant_handler.respond env
-        rescue StandardError => e
-          @logger.error 'Error ocurred in mock service:'
-          @logger.ap e, :error
-          @logger.ap e.backtrace
-          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
-          raise e
-        end
-        response
-      end
-
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'pact/consumer/mock_service/rack_request_helper'
-require 'pact/consumer/mock_service/mock_service_administration_endpoint'
-
-module Pact
-  module Consumer
-
-    class InteractionDelete < MockServiceAdministrationEndpoint
-
-      include RackRequestHelper
-
-      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
-        'DELETE'
-      end
-
-      def respond env
-        interaction_list.clear
-        logger.info "Cleared interactions before example \"#{params_hash(env)['example_description']}\""
-        [200, {}, ['Deleted interactions']]
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-module Pact
-  module Consumer
-    class InteractionList
-
-      attr_reader :interactions
-      attr_reader :unexpected_requests
-      attr_reader :interaction_mismatches
-
-      def initialize
-        clear
-      end
-
-      # For testing, sigh
-      def clear
-        @interactions = []
-        @matched_interactions = []
-        @interaction_mismatches = []
-        @unexpected_requests = []
-      end
-
-      def add interactions
-        @interactions << interactions
-      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
-
-      def all_matched?
-        interaction_diffs.empty?
-      end
-
-      def missing_interactions
-        @interactions - @matched_interactions - @interaction_mismatches.collect(&:candidate_interactions).flatten
-      end
-
-      def missing_interactions_summaries
-        missing_interactions.collect(&:request).collect(&:method_and_path)
-      end
-
-      def interaction_mismatches_summaries
-        interaction_mismatches.collect(&:short_summary)
-      end
-
-      def unexpected_requests_summaries
-        unexpected_requests.collect(&:method_and_path)
-      end
-
-      def interaction_diffs
-        {
-          :missing_interactions => missing_interactions_summaries,
-          :interaction_mismatches => interaction_mismatches_summaries,
-          :unexpected_requests => unexpected_requests_summaries
-        }.inject({}) do | hash, pair |
-          hash[pair.first] = pair.last if pair.last.any?
-          hash
-        end
-      end
-
-      def find_candidate_interactions actual_request
-        interactions.select do | interaction |
-          interaction.request.matches_route? actual_request
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-module Pact
-  module Consumer
-
-    # Presents the differences between an actual request, and a list of
-    # 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

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