pact 0.1.28 → 1.3.3

data/lib/pact/consumer/configuration/service_provider.rb

@@ -0,0 +1,40 @@
+require 'pact/shared/dsl'
+require 'pact/consumer/configuration/mock_service'
+
+module Pact
+  module Consumer
+    module Configuration
+      class ServiceProvider
+
+        extend Pact::DSL
+
+        attr_accessor :service, :consumer_name, :name
+
+        def initialize name, consumer_name
+          @name = name
+          @service = nil
+          @consumer_name = consumer_name
+        end
+
+        dsl do
+          def mock_service name, &block
+            self.service = MockService.build(name, consumer_name, self.name, &block)
+          end
+        end
+
+        def finalize
+          validate
+        end
+
+        private
+
+        def validate
+          raise "Please configure a service for #{name}" unless service
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/pact/consumer/configuration.rb

@@ -0,0 +1,11 @@
+require 'pact/configuration'
+require 'pact/consumer/consumer_contract_builders'
+require 'pact/consumer/consumer_contract_builder'
+require 'pact/consumer/configuration/service_consumer'
+require 'pact/consumer/configuration/service_provider'
+require 'pact/consumer/configuration/dsl'
+require 'pact/consumer/configuration/configuration_extensions'
+
+
+Pact.send(:extend, Pact::Consumer::DSL)
+Pact::Configuration.send(:include, Pact::Consumer::Configuration::ConfigurationExtensions)

data/lib/pact/consumer/consumer_contract_builder.rb

@@ -1,78 +1,75 @@
 require 'uri'
 require 'json/add/regexp'
-require 'pact/json_warning'
 require 'pact/logging'
+require 'pact/consumer/mock_service_client'
+require 'pact/consumer/interaction_builder'
 
 module Pact
   module Consumer
+
     class ConsumerContractBuilder
 
-      include Pact::JsonWarning
       include Pact::Logging
 
-      attr_reader :uri
-      attr_reader :consumer_contract
-      attr_reader :pactfile_write_mode
+      attr_reader :consumer_contract, :mock_service_base_url
 
       def initialize(attributes)
-        @interactions = {}
-        @producer_state = nil
-        @pactfile_write_mode = attributes[:pactfile_write_mode]
-        @consumer_contract = Pact::ConsumerContract.new(
-          :consumer => ServiceConsumer.new(name: attributes[:consumer_name]),
-          :producer => ServiceProducer.new(name: attributes[:producer_name])
-          )
-        @uri = URI("http://localhost:#{attributes[:port]}")
-        @http = Net::HTTP.new(uri.host, uri.port)
-        if pactfile_write_mode == :update && File.exist?(consumer_contract.pactfile_path)
-          load_existing_interactions
-        end
+        @interaction_builder = nil
+        @consumer_contract_details = {
+          consumer: {name: attributes[:consumer_name]},
+          provider: {name: attributes[:provider_name]},
+          pactfile_write_mode: attributes[:pactfile_write_mode].to_s
+        }
+        @mock_service_client = MockServiceClient.new(attributes[:port])
+        @mock_service_base_url = "http://localhost:#{attributes[:port]}"
+      end
+
+      def given(provider_state)
+        interaction_builder.given(provider_state)
       end
 
-      def load_existing_interactions
-        json = File.read(consumer_contract.pactfile_path)
-        if json.size > 0
-          existing_consumer_contract = Pact::ConsumerContract.from_json json
-          existing_consumer_contract.interactions.each do | interaction |
-            @interactions["#{interaction.description} given #{interaction.producer_state}"] = interaction
+      def upon_receiving(description)
+        interaction_builder.upon_receiving(description)
+      end
+
+      def interaction_builder
+        @interaction_builder ||=
+        begin
+          interaction_builder = InteractionBuilder.new
+          interaction_builder.on_interaction_fully_defined do | interaction |
+            self.handle_interaction_fully_defined(interaction)
           end
-          consumer_contract.interactions = @interactions.values
+          interaction_builder
         end
       end
 
-      def given(producer_state)
-        @producer_state = producer_state
-        self
+      def verify example_description
+        mock_service_client.verify example_description
+      end
+
+      def log msg
+        mock_service_client.log msg
       end
 
-      def upon_receiving(description)
-        interaction_builder = InteractionBuilder.new(description, @producer_state)
-        producer = self
-        interaction_builder.on_interaction_fully_defined do | interaction |
-          producer.handle_interaction_fully_defined(interaction)
-        end
-        @interactions["#{description} given #{@producer_state}"] ||= interaction_builder.interaction
-        consumer_contract.interactions = @interactions.values
-        interaction_builder
+      def write_pact
+        mock_service_client.write_pact @consumer_contract_details
       end
 
-      def handle_interaction_fully_defined interaction
-        @http.request_post('/interactions', interaction.to_json_with_generated_response)
-        @producer_state = nil
-        consumer_contract.update_pactfile
+      def wait_for_interactions options = {}
+        wait_max_seconds = options.fetch(:wait_max_seconds, 3)
+        poll_interval = options.fetch(:poll_interval, 0.1)
+        mock_service_client.wait_for_interactions wait_max_seconds, poll_interval
       end
 
-      def verify example_description
-        http = Net::HTTP.new(uri.host, uri.port)
-        response = http.request_get("/verify?example_description=#{URI.encode(example_description)}")
-        raise response.body unless response.is_a? Net::HTTPSuccess
+      def handle_interaction_fully_defined interaction
+        mock_service_client.add_expected_interaction interaction #TODO: What will happen if duplicate added?
+        self.interaction_builder = nil
       end
 
       private
 
-      def filenamify name
-        name.downcase.gsub(/\s/, '_')
-      end
+      attr_reader :mock_service_client
+      attr_writer :interaction_builder
 
     end
   end

data/lib/pact/consumer/interaction_builder.rb

@@ -0,0 +1,41 @@
+require 'net/http'
+require 'pact/reification'
+require 'pact/consumer_contract/interaction'
+
+module Pact
+  module Consumer
+    class InteractionBuilder
+
+      attr_reader :interaction
+
+      def initialize
+        @interaction = Interaction.new
+      end
+
+      def upon_receiving description
+        @interaction.description = description
+        self
+      end
+
+      def given provider_state
+        @interaction.provider_state = provider_state.nil? ? nil : provider_state.to_s
+        self
+      end
+
+      def with(request_details)
+        interaction.request = Pact::Request::Expected.from_hash(request_details)
+        self
+      end
+
+      def will_respond_with(response)
+        interaction.response = response
+        @callback.call interaction
+        self
+      end
+
+      def on_interaction_fully_defined &block
+        @callback = block
+      end
+    end
+  end
+end

data/lib/pact/consumer/interactions_filter.rb

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

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

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

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

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

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