pact 0.1.28 → 0.1.35

data/lib/pact/consumer/consumer_contract_builder.rb

@@ -1,30 +1,27 @@
 require 'uri'
 require 'json/add/regexp'
-require 'pact/json_warning'
 require 'pact/logging'
+require 'pact/consumer/mock_service_client'
 
 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 :mock_service_client
 
       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)
+        @mock_service_client = MockServiceClient.new(attributes[:producer_name], attributes[:port])
+        if attributes[:pactfile_write_mode] == :update && File.exist?(consumer_contract.pactfile_path)
           load_existing_interactions
         end
       end
@@ -57,15 +54,19 @@ module Pact
       end
 
       def handle_interaction_fully_defined interaction
-        @http.request_post('/interactions', interaction.to_json_with_generated_response)
+        mock_service_client.add_expected_interaction interaction
         @producer_state = nil
         consumer_contract.update_pactfile
       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
+        mock_service_client.verify example_description
+      end
+
+      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
 
       private

data/lib/pact/consumer/dsl.rb

@@ -2,14 +2,63 @@ require_relative 'consumer_contract_builders'
 
 module Pact::Consumer
    module DSL
+
+      def service_consumer name, &block
+        ServiceConsumerDSL.new(name, &block).create_service_consumer
+      end
+
+      class ServiceConsumerDSL
+
+        def initialize name, &block
+          @name = name
+          consumer = Pact::Consumer::ServiceConsumer.new name: @name
+          @app = nil
+          @port = nil
+          instance_eval(&block)
+        end
+
+        def validate
+          raise "Please provide a consumer name" unless (@name && !@name.empty?)
+          raise "Please provide a port for the consumer app" if @app && !@port
+        end
+
+        def app app
+          @app = app
+        end
+
+        def port port
+          @port = port
+        end
+
+        def has_pact_with service_provider_name, &block
+          Producer.new(service_provider_name, @name, &block).create_consumer_contract_builder
+        end
+
+        def create_service_consumer
+          validate
+          register_consumer_app if @app
+        end
+
+        def register_consumer_app
+          Pact::Consumer::AppManager.instance.register @app, @port
+        end
+      end
+
+
+
+
+      #OLD ####
       def with_producer name, &block
          Producer.new(name, &block).create_consumer_contract_builder
       end
 
+      alias_method :with_service_provider, :with_producer
+
       class Producer
-         def initialize name, &block
+         def initialize name, consumer_name = Pact.configuration.consumer.name, &block
             @name = name
             @service = nil
+            @consumer_name = consumer_name
             instance_eval(&block)
          end
 
@@ -30,7 +79,7 @@ module Pact::Consumer
 
         def consumer_contract_builder_from_attributes
           consumer_contract_builder_fields = {
-            :consumer_name => Pact.configuration.consumer.name,
+            :consumer_name => @consumer_name,
             :producer_name => @name,
             :pactfile_write_mode => Pact.configuration.pactfile_write_mode
             }

data/lib/pact/consumer/interaction.rb

@@ -10,18 +10,18 @@ module Pact
 
       attr_accessor :description, :request, :response, :producer_state
 
-      def initialize options
-        @description = options[:description]
-        @request = options[:request]
-        @response = options[:response]
-        @producer_state = options[:producer_state]
+      def initialize attributes
+        @description = attributes[:description]
+        @request = attributes[:request]
+        @response = attributes[:response]
+        @producer_state = attributes[:producer_state]
       end
 
-      def self.from_hash options
-        new(:description => options['description'],
-            :producer_state => options['producer_state'],
-            :request => Pact::Request::Expected.from_hash(options['request']),
-            :response => options['response']
+      def self.from_hash hash
+        new(:description => hash['description'],
+            :producer_state => hash['producer_state'],
+            :request => Pact::Request::Expected.from_hash(hash['request']),
+            :response => hash['response']
           )
       end
 
@@ -37,9 +37,12 @@ module Pact
         as_json.to_json(options)
       end
 
+      def as_json_for_mock_service
+        {:response => Reification.from_term(response), :request => @request.as_json_with_options, :description => description }
+      end
 
-      def to_json_with_generated_response
-        as_json.tap { | hash | hash[:response] = Reification.from_term(response) }.to_json
+      def to_json_for_mock_service
+        as_json_for_mock_service.to_json
       end
     end
 

data/lib/pact/consumer/mock_service.rb

@@ -56,7 +56,7 @@ module Pact
       end
 
       def interaction_diffs
-        { 
+        {
           :missing_interactions => missing_interactions,
           :unexpected_requests => unexpected_requests
         }.inject({}) do | hash, pair |
@@ -222,9 +222,9 @@ module Pact
           expected_request.match actual_request
         end
         if matching_interactions.size > 1
-          @logger.info "Multiple interactions found on #{@name}:"
+          @logger.error "Multiple interactions found on #{@name}:"
           @logger.ap matching_interactions
-          raise 'Multiple interactions found!'
+          raise "Multiple interactions found for path #{actual_request.path}!"
         end
         if matching_interactions.empty?
           handle_unrecognised_request(actual_request, candidates)
@@ -238,12 +238,12 @@ module Pact
       end
 
       def handle_unrecognised_request request, candidates
-        @logger.ap "No interaction found on #{@name} for request \"#{candidates.map(&:description).join(', ')}\""
-        @logger.ap 'Interaction diffs for that route:'
+        @logger.error "No interaction found on #{@name} amongst expected requests \"#{candidates.map(&:description).join(', ')}\""
+        @logger.error 'Interaction diffs for that route:'
         interaction_diff = candidates.map do |candidate|
-          diff(candidate.as_json, request.as_json)
+          candidate.difference(request)
         end.to_a
-        @logger.ap(interaction_diff)
+        @logger.ap(interaction_diff, :error)
         response = {message: "No interaction found for #{request.path}", interaction_diff:  interaction_diff}
         [500, {'Content-Type' => 'application/json'}, [response.to_json]]
       end
@@ -262,6 +262,27 @@ module Pact
       end
     end
 
+    class MissingInteractionsGet
+      include RackHelper
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      def match? env
+        env['REQUEST_PATH'].start_with?('/number_of_missing_interactions') &&
+            env['REQUEST_METHOD'] == 'GET'
+      end
+
+      def respond env
+        number_of_missing_interactions = InteractionList.instance.missing_interactions.size
+        @logger.info "Number of missing interactions for mock \"#{@name}\" = #{number_of_missing_interactions}"
+        [200, {}, ["#{number_of_missing_interactions}"]]
+      end
+
+    end
+
     class VerificationGet
 
       include RackHelper
@@ -279,10 +300,10 @@ module Pact
 
       def respond env
         if InteractionList.instance.all_matched?
-          @logger.info "Veryifying - interactions matched for example \"#{example_description(env)}\""
+          @logger.info "Verifying - interactions matched for example \"#{example_description(env)}\""
           [200, {}, ['Interactions matched']]
         else
-          @logger.warn "Verifying - actual interactions do not match expected interactions for example \"#{example_description(env)}\". Missing interactions:"
+          @logger.warn "Verifying - actual interactions do not match expected interactions for example \"#{example_description(env)}\". Interaction diffs:"
           @logger.ap InteractionList.instance.interaction_diffs, :warn
           [500, {}, ["Actual interactions do not match expected interactions for mock #{@name}. See #{@log_description} for details."]]
         end
@@ -310,6 +331,7 @@ module Pact
         @handlers = [
           StartupPoll.new(@name, @logger),
           CapybaraIdentify.new(@name, @logger),
+          MissingInteractionsGet.new(@name, @logger),
           VerificationGet.new(@name, @logger, log_description),
           InteractionPost.new(@name, @logger),
           InteractionDelete.new(@name, @logger),

data/lib/pact/consumer/mock_service_client.rb

@@ -0,0 +1,47 @@
+module Pact
+  module Consumer
+    class MockServiceClient
+      def initialize name, port
+        @http = Net::HTTP.new('localhost', port)
+      end
+
+      def verify example_description
+        response = http.request_get("/verify?example_description=#{URI.encode(example_description)}")
+        raise response.body unless response.is_a? Net::HTTPSuccess
+      end
+
+      def wait_for_interactions wait_max_seconds, poll_interval
+        wait_until_true(wait_max_seconds, poll_interval) do
+          response = http.request_get("/number_of_missing_interactions")
+          response.body == '0'
+        end
+      end
+
+      def clear_interactions example_description
+        http.delete("/interactions?example_description=#{URI.encode(example_description)}")
+      end
+
+      def add_expected_interaction interaction
+        http.request_post('/interactions', interaction.to_json_for_mock_service)
+      end
+
+      def self.clear_interactions port, example_description
+        Net::HTTP.new("localhost", port).delete("/interactions?example_description=#{URI.encode(example_description)}")
+      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

data/lib/pact/consumer/rspec.rb

@@ -2,6 +2,7 @@ require_relative '../configuration'
 require_relative '../consumer'
 require_relative 'dsl'
 require_relative 'configuration_dsl'
+require 'pact/consumer/consumer_contract_builder'
 
 module Pact
   module Consumer
@@ -23,7 +24,7 @@ RSpec.configure do |config|
     example_description = "#{example.example.example_group.description} #{example.example.description}"
     Pact.configuration.logger.info "Clearing all expectations"
     Pact::Consumer::AppManager.instance.ports_of_mock_services.each do | port |
-      Net::HTTP.new("localhost", port).delete("/interactions?example_description=#{URI.encode(example_description)}")
+      Pact::Consumer::MockServiceClient.clear_interactions port, example_description
     end
   end
 

data/lib/pact/consumer_contract.rb

@@ -4,12 +4,13 @@ require 'pact/consumer/interaction'
 require 'pact/logging'
 require 'pact/json_warning'
 require 'date'
+require 'pact/version'
 
 module Pact
 	class ConsumerContract
 
 		include Pact::Logging
-      include Pact::JsonWarning		
+      include Pact::JsonWarning
 
 		attr_accessor :interactions
 		attr_accessor :consumer

data/lib/pact/matchers/matchers.rb

@@ -5,8 +5,29 @@ module Pact
   module Matchers
 
     NO_DIFF_INDICATOR = 'no difference here!'
+    UNEXPECTED_KEY = '<key not to be present>'
+    DEFAULT_OPTIONS = {allow_unexpected_keys: true, structure: false}.freeze
 
-    def diff expected, actual, options = {}
+    class KeyNotFound
+      def == other
+        other.is_a? KeyNotFound
+      end
+
+      def eql? other
+        self == other
+      end
+
+      def to_s
+        "<key not found>"
+      end
+
+      def to_json options = {}
+        to_s
+      end
+    end
+
+    def diff expected, actual, opts = {}
+      options = DEFAULT_OPTIONS.merge(opts)
       case expected
       when Hash then hash_diff(expected, actual, options)
       when Array then array_diff(expected, actual, options)
@@ -31,17 +52,7 @@ module Pact
     def array_diff expected, actual, options
       if actual.is_a? Array
         if expected.length == actual.length
-          difference = []
-          diff_found = false
-          expected.each_with_index do | item, index|
-            if (item_diff = diff(item, actual[index], options)).any?
-              diff_found = true
-              difference << item_diff
-            else
-              difference << NO_DIFF_INDICATOR
-            end
-          end
-          diff_found ? difference : {}
+          actual_array_diff expected, actual, options
         else
           {expected: expected, actual: actual}
         end
@@ -50,14 +61,44 @@ module Pact
       end
     end
 
-    def hash_diff expected, actual, options
-      if actual.is_a? Hash
-        expected.keys.inject({}) do |diff, key|
-          if (diff_at_key = diff(expected[key], actual[key], options)).any?
-            diff[key] = diff_at_key
-          end
+    def actual_array_diff expected, actual, options
+      difference = []
+      diff_found = false
+      expected.each_with_index do | item, index|
+        if (item_diff = diff(item, actual.fetch(index, KeyNotFound.new), options)).any?
+          diff_found = true
+          difference << item_diff
+        else
+          difference << NO_DIFF_INDICATOR
+        end
+      end
+      diff_found ? difference : {}
+    end
+
+    def actual_hash_diff expected, actual, options
+      difference = expected.keys.inject({}) do |diff, key|
+        if (diff_at_key = diff(expected[key], actual.fetch(key, KeyNotFound.new), options)).any?
+          diff[key] = diff_at_key
+        end
+        diff
+      end
+      difference.merge(check_for_unexpected_keys(expected, actual, options))
+    end
+
+    def check_for_unexpected_keys expected, actual, options
+      if options[:allow_unexpected_keys]
+        {}
+      else
+        (actual.keys - expected.keys).inject({}) do | diff, key |
+          diff[key] = {:expected => UNEXPECTED_KEY, :actual => actual[key]}
           diff
         end
+      end
+    end
+
+    def hash_diff expected, actual, options
+      if actual.is_a? Hash
+        actual_hash_diff expected, actual, options
       else
         {expected: expected, actual: actual}
       end

data/lib/pact/producer/dsl.rb

@@ -0,0 +1,61 @@
+module Pact
+
+   module Producer
+      module DSL
+
+         module Configuration
+            def provider= provider
+               @producer = provider
+            end
+         end
+
+         Pact::Configuration.send(:include, Configuration)
+
+         def service_provider name, &block
+            service_provider = ServiceProviderDSL.new(name, &block).create_service_provider
+            Pact.configuration.provider = service_provider
+            service_provider
+         end
+
+        class ServiceProviderConfig
+           attr_accessor :name
+
+           def initialize name, &app_block
+             @name = name
+             @app_block = app_block
+           end
+
+           def app
+             @app_block.call
+           end
+         end
+
+         class ServiceProviderDSL
+
+           def initialize name, &block
+             @name = name
+             @app = nil
+             instance_eval(&block)
+           end
+
+           def validate
+             raise "Please provide a name for the Producer" unless @name
+             raise "Please configure an app for the Producer" unless @app_block
+           end
+
+           def name name
+             @name = name
+           end
+
+           def app &block
+             @app_block = block
+           end
+
+           def create_service_provider
+             validate
+             ServiceProviderConfig.new(@name, &@app_block)
+           end
+         end
+      end
+   end
+end

data/lib/pact/producer/producer_state.rb

@@ -11,6 +11,9 @@ module Pact
         instance_eval(&block)
         ProducerState.current_namespaces.pop
       end
+
+      alias_method :provider_states_for, :with_consumer
+      alias_method :provider_state, :producer_state
     end
 
     class ProducerState
@@ -22,6 +25,10 @@ module Pact
         ProducerState.new(name, current_namespaces.join('.'), &block)
       end
 
+      def self.provider_state name, &block
+        producer_state name, &block
+      end
+
       def self.register name, producer_state
         producer_states[name] = producer_state
       end

data/lib/pact/producer/rspec.rb

@@ -4,6 +4,7 @@ require 'pact/json_warning'
 require_relative 'matchers'
 require_relative 'test_methods'
 require_relative 'configuration_dsl'
+require_relative 'dsl'
 
 module Pact
   module Producer
@@ -111,6 +112,7 @@ module Pact
         end
 
         def save_pactfile_to_tmp pact, name
+          FileUtils.mkdir_p Pact.configuration.tmp_dir
           File.open(Pact.configuration.tmp_dir + "/#{name}", "w") { |file|  file << pact}
         end
 

data/lib/pact/provider/rspec.rb

@@ -0,0 +1 @@
+require 'pact/producer/rspec'

data/lib/pact/request.rb

@@ -35,15 +35,15 @@ module Pact
     end
 
     class Base
-    include Pact::Matchers
-    extend Pact::Matchers
+      include Pact::Matchers
+      extend Pact::Matchers
 
-    NULL_EXPECTATION = NullExpectation.new
+      NULL_EXPECTATION = NullExpectation.new
 
-      attr_reader :method, :path, :headers, :body, :query
+      attr_reader :method, :path, :headers, :body, :query, :options
 
       def self.from_hash(hash)
-        sym_hash = hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
+        sym_hash = symbolize_keys hash
         method = sym_hash.fetch(:method)
         path = sym_hash.fetch(:path)
         query = sym_hash.fetch(:query, NULL_EXPECTATION)
@@ -52,6 +52,10 @@ module Pact
         new(method, path, headers, body, query)
       end
 
+      def self.symbolize_keys hash
+        hash.inject({}) { |memo, (k,v)| memo[k.to_sym] = v; memo }
+      end
+
       def initialize(method, path, headers, body, query)
         @method = method.to_s
         @path = path.chomp('/')
@@ -76,18 +80,31 @@ module Pact
         base_json
       end
 
+      def as_json_without_body
+        keep_keys = [:method, :path, :headers, :query]
+        as_json.reject{ |key, value| !keep_keys.include? key }
+      end
+
     end
 
     class Expected < Base
 
+      DEFAULT_OPTIONS = {:allow_unexpected_keys => false}.freeze
       attr_accessor :description
+      attr_accessor :options
 
       def self.from_hash(hash)
         request = super
         request.description = hash.fetch(:description, nil)
+        request.options = symbolize_keys(hash).fetch(:options, {})
         request
       end
 
+      def initialize(method, path, headers, body, query, options = {})
+        super(method, path, headers, body, query)
+        @options = options
+      end
+
       def match(actual_request)
         difference(actual_request).empty?
       end
@@ -97,7 +114,26 @@ module Pact
       end
 
       def difference(actual_request)
-        diff(as_json, actual_request.as_json)
+        request_diff = diff(as_json_without_body, actual_request.as_json_without_body)
+        unless body.is_a? NullExpectation
+          request_diff.merge(body_difference(actual_request.body))
+        else
+          request_diff
+        end
+      end
+
+      def body_difference(actual_body)
+        diff({:body => body}, {body: actual_body}, allow_unexpected_keys: runtime_options[:allow_unexpected_keys_in_body])
+      end
+
+      def as_json_with_options
+        as_json.merge( options.empty? ? {} : { options: options} )
+      end
+
+      # Don't want to put the default options in the pact json just yet, so calculating these at run time, rather than assigning
+      # the result to @options
+      def runtime_options
+        DEFAULT_OPTIONS.merge(self.class.symbolize_keys(options))
       end
 
     end

data/lib/pact/verification_task.rb

@@ -15,11 +15,8 @@ require 'pact/producer/pact_spec_runner'
 	The support_file should include code that makes your rack app available for the rack testing framework.
 	Eg.
 
-	Pact.configure do | config |
-		config.producer do
-			name "My Producer"
-			app { TestApp.new }
-		end
+	Pact.service_provider "My Provider" do
+		app { TestApp.new }
 	end
 
 	It should also load all your app's dependencies (eg by calling out to spec_helper)

data/lib/pact/version.rb

@@ -1,3 +1,3 @@
 module Pact
-  VERSION = "0.1.28"
+  VERSION = "0.1.35"
 end