pact 0.1.28

data/lib/pact/consumer/configuration_dsl.rb

@@ -0,0 +1,71 @@
+require_relative 'service_consumer'
+require_relative 'consumer_contract_builders'
+require_relative '../configuration'
+
+module Pact
+  module Consumer
+
+
+    module Configuration
+      def add_producer_verification &block
+        producer_verifications << block
+      end
+      def producer_verifications
+        @producer_verifications ||= []
+      end
+    end
+
+    module ConfigurationDSL
+
+      def consumer &block
+        if block_given?
+          @consumer = ConsumerDSL.new(&block).create_service_consumer
+        elsif @consumer
+          @consumer
+        else
+          raise "Please configure a consumer before configuring producers"
+        end
+      end
+
+      class ConsumerDSL
+
+        def initialize &block
+          @app = nil
+          @port = nil
+          @name = nil
+          instance_eval(&block)
+        end
+
+        def validate
+          raise "Please provide a consumer name" unless @name
+          raise "Please provide a port for the consumer app" if @app && !@port
+        end
+
+        def name name
+          @name = name
+        end
+
+        def app app
+          @app = app
+        end
+
+        def port port
+          @port = port
+        end
+
+        def create_service_consumer
+          validate
+          register_consumer_app if @app
+          Pact::Consumer::ServiceConsumer.new name: @name
+        end
+
+        def register_consumer_app
+          Pact::Consumer::AppManager.instance.register @app, @port
+        end
+      end
+    end
+  end
+end
+
+Pact::Configuration.send(:include, Pact::Consumer::ConfigurationDSL)
+Pact::Configuration.send(:include, Pact::Consumer::Configuration)

data/lib/pact/consumer/consumer_contract_builder.rb

@@ -0,0 +1,79 @@
+require 'uri'
+require 'json/add/regexp'
+require 'pact/json_warning'
+require 'pact/logging'
+
+module Pact
+  module Consumer
+    class ConsumerContractBuilder
+
+      include Pact::JsonWarning
+      include Pact::Logging
+
+      attr_reader :uri
+      attr_reader :consumer_contract
+      attr_reader :pactfile_write_mode
+
+      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
+      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
+          end
+          consumer_contract.interactions = @interactions.values
+        end
+      end
+
+      def given(producer_state)
+        @producer_state = producer_state
+        self
+      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
+      end
+
+      def handle_interaction_fully_defined interaction
+        @http.request_post('/interactions', interaction.to_json_with_generated_response)
+        @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
+      end
+
+      private
+
+      def filenamify name
+        name.downcase.gsub(/\s/, '_')
+      end
+
+    end
+  end
+end

data/lib/pact/consumer/consumer_contract_builders.rb

@@ -0,0 +1,10 @@
+module Pact
+  module Consumer
+    module ConsumerContractBuilders
+      # Placeholder for mock service methods which will be dynamically created
+      # from the Pact configuration.
+
+      # To be included in RSpec
+    end
+  end
+end

data/lib/pact/consumer/dsl.rb

@@ -0,0 +1,98 @@
+require_relative 'consumer_contract_builders'
+
+module Pact::Consumer
+   module DSL
+      def with_producer name, &block
+         Producer.new(name, &block).create_consumer_contract_builder
+      end
+
+      class Producer
+         def initialize name, &block
+            @name = name
+            @service = nil
+            instance_eval(&block)
+         end
+
+         def service name, &block
+            @service = Service.new(name, &block)
+         end
+
+         alias_method :mock_service, :service
+
+        def create_consumer_contract_builder
+          validate
+          consumer_contract_builder_from_attributes
+        end
+
+        def validate
+          raise "Please configure a service for #{@name}" unless @service
+        end
+
+        def consumer_contract_builder_from_attributes
+          consumer_contract_builder_fields = {
+            :consumer_name => Pact.configuration.consumer.name,
+            :producer_name => @name,
+            :pactfile_write_mode => Pact.configuration.pactfile_write_mode
+            }
+          @service.configure_consumer_contract_builder consumer_contract_builder_fields
+        end
+      end
+
+      class Service
+         def initialize name, &block
+            @name = name
+            @port = nil
+            @standalone = false
+            @verify = false
+            instance_eval(&block)
+         end
+
+         def port port
+            @port = port
+         end
+
+         def standalone standalone
+            @standalone = standalone
+         end
+
+         def verify verify
+            @verify = verify
+         end
+
+         def configure_consumer_contract_builder consumer_contract_builder_fields
+            validate
+            unless @standalone
+              AppManager.instance.register_mock_service_for consumer_contract_builder_fields[:producer_name], "http://localhost:#{@port}"
+            end
+            consumer_contract_builder = Pact::Consumer::ConsumerContractBuilder.new consumer_contract_builder_fields.merge({port: @port})
+            create_mock_services_module_method consumer_contract_builder
+            setup_verification(consumer_contract_builder) if @verify
+            consumer_contract_builder
+         end
+
+
+        def setup_verification consumer_contract_builder
+          Pact.configuration.add_producer_verification do | example_description |
+            consumer_contract_builder.verify example_description
+          end
+        end
+
+         private
+
+         # This makes the consumer_contract_builder available via a module method with the given identifier
+         # as the method name.
+         # I feel this should be defined somewhere else, but I'm not sure where
+         def create_mock_services_module_method consumer_contract_builder
+           Pact::Consumer::ConsumerContractBuilders.send(:define_method, @name.to_sym) do
+             consumer_contract_builder
+           end
+         end
+
+         def validate
+            raise "Please provide a port for service #{@name}" unless @port
+         end
+      end
+   end
+end
+
+Pact.send(:extend, Pact::Consumer::DSL)

data/lib/pact/consumer/interaction.rb

@@ -0,0 +1,70 @@
+require 'net/http'
+require 'pact/reification'
+require 'pact/request'
+#require 'json/add/core'
+
+module Pact
+  module Consumer
+
+    class Interaction
+
+      attr_accessor :description, :request, :response, :producer_state
+
+      def initialize options
+        @description = options[:description]
+        @request = options[:request]
+        @response = options[:response]
+        @producer_state = options[: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']
+          )
+      end
+
+      def as_json
+        {
+          :description => @description,
+          :request => @request.as_json,
+          :response => @response,
+        }.tap{ | hash | hash[:producer_state] = @producer_state if @producer_state }
+      end
+
+      def to_json(options = {})
+        as_json.to_json(options)
+      end
+
+
+      def to_json_with_generated_response
+        as_json.tap { | hash | hash[:response] = Reification.from_term(response) }.to_json
+      end
+    end
+
+    class InteractionBuilder
+
+      attr_reader :interaction
+
+      def initialize(description, producer_state)
+        producer_state = producer_state.nil? ? nil : producer_state.to_s
+        @interaction = Interaction.new(:description => description, :producer_state => producer_state)
+      end
+
+      def with(request_details)
+        interaction.request = Request::Expected.from_hash(request_details)
+        self
+      end
+
+      def will_respond_with(response)
+        interaction.response = response
+        @callback.call interaction
+      end
+
+      def on_interaction_fully_defined &block
+        @callback = block
+      end
+    end
+  end
+end

data/lib/pact/consumer/mock_service.rb

@@ -0,0 +1,340 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'hashie'
+require 'singleton'
+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 'json/add/regexp'
+require 'pact/matchers'
+
+AwesomePrint.defaults = {
+  indent: -2,
+  plain: true,
+  index: false
+}
+
+module Pact
+  module Consumer
+
+    class InteractionList
+      include Singleton
+
+      attr_reader :interactions
+      attr_reader :unexpected_requests
+
+      def initialize
+        clear
+      end
+
+      # For testing, sigh
+      def clear
+        @interactions = []
+        @matched_interactions = []
+        @unexpected_requests = []
+      end
+
+      def add interactions
+        @interactions << interactions
+      end
+
+      def register_matched interaction
+        @matched_interactions << interaction
+      end
+
+      def register_unexpected request
+        @unexpected_requests << request
+      end
+
+      def all_matched?
+        interaction_diffs.empty?
+      end
+
+      def missing_interactions
+        @interactions - @matched_interactions
+      end
+
+      def interaction_diffs
+        { 
+          :missing_interactions => missing_interactions,
+          :unexpected_requests => unexpected_requests
+        }.inject({}) do | hash, pair |
+          hash[pair.first] = pair.last if pair.last.any?
+          hash
+        end
+      end
+
+    end
+
+    module RackHelper
+      def params_hash env
+        env["QUERY_STRING"].split("&").collect{| param| param.split("=")}.inject({}){|params, param| params[param.first] = URI.decode(param.last); params }
+      end
+    end
+
+    class StartupPoll
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      def match? env
+        env['REQUEST_PATH'] == '/index.html' &&
+          env['REQUEST_METHOD'] == 'GET'
+      end
+
+      def respond env
+        @logger.info "#{@name} started up"
+        [200, {}, ['Started up fine']]
+      end
+    end
+
+    class CapybaraIdentify
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      def match? env
+        env["PATH_INFO"] == "/__identify__"
+      end
+
+      def respond env
+        [200, {}, [object_id.to_s]]
+      end
+    end
+
+    class InteractionDelete
+
+      include RackHelper
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      def match? env
+        env['REQUEST_PATH'].start_with?('/interactions') &&
+          env['REQUEST_METHOD'] == 'DELETE'
+      end
+
+      def respond env
+        InteractionList.instance.clear
+        @logger.info "Cleared interactions before example \"#{params_hash(env)['example_description']}\""
+        [200, {}, ['Deleted interactions']]
+      end
+    end
+
+    class InteractionPost
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      def match? env
+        env['REQUEST_PATH'] == '/interactions' &&
+          env['REQUEST_METHOD'] == 'POST'
+      end
+
+      def respond env
+        interactions = Hashie::Mash.new(JSON.load(env['rack.input'].string))
+        InteractionList.instance.add interactions
+        @logger.info "Added interaction to #{@name}"
+        @logger.ap interactions
+        [200, {}, ['Added interactions']]
+      end
+    end
+
+    module RequestExtractor
+
+      REQUEST_KEYS = Hashie::Mash.new({
+        'REQUEST_METHOD' => :method,
+        'REQUEST_PATH' => :path,
+        'QUERY_STRING' => :query,
+        'rack.input' => :body
+      })
+
+      def request_from env
+        request = env.inject({}) do |memo, (k, v)|
+          request_key = REQUEST_KEYS[k]
+        memo[request_key] = v if request_key
+        memo
+        end
+
+        mashed_request = Hashie::Mash.new request
+        mashed_request[:headers] = headers_from env
+        body_string = mashed_request[:body].read
+
+        if body_string.empty?
+          mashed_request.delete :body
+        else
+          body_is_json = mashed_request[:headers]['Content-Type'] =~ /json/
+          mashed_request[:body] =  body_is_json ? JSON.parse(body_string) : body_string
+        end
+        mashed_request[:method] = mashed_request[:method].downcase
+        mashed_request
+      end
+
+      def headers_from env
+        headers = env.reject{ |key, value| !(key.start_with?("HTTP") || key == 'CONTENT_TYPE')}
+        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
+
+    class InteractionReplay
+      include Pact::Matchers
+      include RequestExtractor
+
+      def initialize name, logger
+        @name = name
+        @logger = logger
+      end
+
+      def match? env
+        true # default handler
+      end
+
+      def respond env
+        find_response request_from(env)
+      end
+
+      private
+
+      def find_response raw_request
+        actual_request = Request::Actual.from_hash(raw_request)
+        @logger.info "#{@name} received request"
+        @logger.ap actual_request.as_json
+        candidates = []
+        matching_interactions = InteractionList.instance.interactions.select do |interaction|
+          expected_request = Request::Expected.from_hash(interaction.request.merge(:description => interaction.description))
+          candidates << expected_request if expected_request.matches_route? actual_request
+          expected_request.match actual_request
+        end
+        if matching_interactions.size > 1
+          @logger.info "Multiple interactions found on #{@name}:"
+          @logger.ap matching_interactions
+          raise 'Multiple interactions found!'
+        end
+        if matching_interactions.empty?
+          handle_unrecognised_request(actual_request, candidates)
+        else
+          response = response_from(matching_interactions.first.response)
+          InteractionList.instance.register_matched matching_interactions.first
+          @logger.info "Found matching response on #{@name}:"
+          @logger.ap response
+          response
+        end
+      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:'
+        interaction_diff = candidates.map do |candidate|
+          diff(candidate.as_json, request.as_json)
+        end.to_a
+        @logger.ap(interaction_diff)
+        response = {message: "No interaction found for #{request.path}", interaction_diff:  interaction_diff}
+        [500, {'Content-Type' => 'application/json'}, [response.to_json]]
+      end
+
+      def response_from response
+        [response.status, (response.headers || {}).to_hash, [render_body(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
+    end
+
+    class VerificationGet
+
+      include RackHelper
+
+      def initialize name, logger, log_description
+        @name = name
+        @logger = logger
+        @log_description = log_description
+      end
+
+      def match? env
+        env['REQUEST_PATH'].start_with?('/verify') &&
+          env['REQUEST_METHOD'] == 'GET'
+      end
+
+      def respond env
+        if InteractionList.instance.all_matched?
+          @logger.info "Veryifying - 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.ap InteractionList.instance.interaction_diffs, :warn
+          [500, {}, ["Actual interactions do not match expected interactions for mock #{@name}. See #{@log_description} for details."]]
+        end
+      end
+
+      def example_description env
+        params_hash(env)['example_description']
+      end
+    end
+
+    class MockService
+
+      def initialize options = {}
+        options = {log_file: STDOUT}.merge options
+        log_stream = options[:log_file]
+        @logger = Logger.new log_stream
+
+        log_description = if log_stream.is_a? File
+           File.absolute_path(log_stream).gsub(Dir.pwd + "/", '')
+        else
+          "standard out/err"
+        end
+
+        @name = options.fetch(:name, "MockService")
+        @handlers = [
+          StartupPoll.new(@name, @logger),
+          CapybaraIdentify.new(@name, @logger),
+          VerificationGet.new(@name, @logger, log_description),
+          InteractionPost.new(@name, @logger),
+          InteractionDelete.new(@name, @logger),
+          InteractionReplay.new(@name, @logger)
+        ]
+      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 Exception => e
+          @logger.ap 'Error ocurred in mock service:'
+          @logger.ap e
+          @logger.ap e.backtrace
+          raise e
+        end
+        response
+      end
+
+    end
+  end
+end