pact 0.1.28 → 1.3.3

data/lib/pact/consumer/mock_service.rb

@@ -1,340 +1,2 @@
-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'
+require 'pact/consumer/mock_service/app'
 
-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

data/lib/pact/consumer/mock_service_client.rb

@@ -0,0 +1,65 @@
+require 'net/http'
+require 'pact/consumer/mock_service_interaction_expectation'
+
+module Pact
+  module Consumer
+    class MockServiceClient
+
+      MOCK_SERVICE_ADMINISTRATON_HEADERS = {'X-Pact-Mock-Service' => 'true'}
+
+      def initialize port
+        @http = Net::HTTP.new('localhost', port)
+      end
+
+      def verify example_description
+        response = http.request_get("/interactions/verification?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
+      end
+
+      def log msg
+        http.request_get("/log?msg=#{URI.encode(msg)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def wait_for_interactions wait_max_seconds, poll_interval
+        wait_until_true(wait_max_seconds, poll_interval) do
+          response = http.request_get("/interactions/missing", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+          JSON.parse(response.body)['size'] == 0
+        end
+      end
+
+      def clear_interactions example_description
+        http.delete("/interactions?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def add_expected_interaction interaction
+        response = http.request_post('/interactions', MockServiceInteractionExpectation.new(interaction).to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
+        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
+      end
+
+      def self.clear_interactions port, example_description
+        Net::HTTP.new("localhost", port).delete("/interactions?example_description=#{URI.encode(example_description)}", MOCK_SERVICE_ADMINISTRATON_HEADERS)
+      end
+
+      def write_pact pacticipant_details
+        response = http.request_post("/pact", pacticipant_details.to_json, MOCK_SERVICE_ADMINISTRATON_HEADERS.merge("Content-Type" => "application/json"))
+        raise "\e[31m#{response.body}\e[m" unless response.is_a? Net::HTTPSuccess
+        response.body
+      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/mock_service_interaction_expectation.rb

@@ -0,0 +1,37 @@
+require 'pact/reification'
+
+# Represents the Interaction in the form required by the MockService
+# The json generated will be posted to the MockService to register the expectation
+module Pact
+  module Consumer
+    class MockServiceInteractionExpectation
+
+
+      def initialize interaction
+        @interaction = interaction
+      end
+
+      def to_hash
+        hash = {:description => interaction.description}
+        hash[:provider_state] = interaction.provider_state if interaction.provider_state
+        options = interaction.request.options.empty? ? {} : { options: interaction.request.options}
+        hash[:request] = interaction.request.as_json.merge(options)
+        hash[:response] = interaction.response
+        hash
+      end
+
+      def as_json options = {}
+        to_hash
+      end
+
+      def to_json opts = {}
+        as_json.to_json(opts)
+      end
+
+      private
+
+      attr_reader :interaction
+
+    end
+  end
+end

data/lib/pact/consumer/request.rb

@@ -0,0 +1,27 @@
+require 'pact/shared/request'
+require 'pact/shared/key_not_found'
+
+module Pact
+  module Consumer
+    module Request
+      class Actual < Pact::Request::Base
+
+        def self.from_hash(hash)
+          sym_hash = symbolize_keys hash
+          method = sym_hash.fetch(:method)
+          path = sym_hash.fetch(:path)
+          query = sym_hash.fetch(:query)
+          headers = sym_hash.fetch(:headers)
+          body = sym_hash.fetch(:body, nil)
+          new(method, path, headers, body, query)
+        end
+
+        protected
+
+        def self.key_not_found
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/rspec.rb

@@ -1,7 +1,6 @@
-require_relative '../configuration'
-require_relative '../consumer'
-require_relative 'dsl'
-require_relative 'configuration_dsl'
+require 'pact/consumer'
+require 'pact/consumer/spec_hooks'
+require 'pact/rspec'
 
 module Pact
   module Consumer
@@ -11,33 +10,24 @@ module Pact
   end
 end
 
+hooks = Pact::Consumer::SpecHooks.new
+
 RSpec.configure do |config|
   config.include Pact::Consumer::RSpec, :pact => true
 
   config.before :all, :pact => true do
-    Pact::Consumer::AppManager.instance.spawn_all
-    FileUtils.mkdir_p Pact.configuration.pact_dir
+    hooks.before_all
   end
 
   config.before :each, :pact => true do | example |
-    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)}")
-    end
+    hooks.before_each Pact::RSpec.full_description(example)
   end
 
   config.after :each, :pact => true do | example |
-    example_description = "#{example.example.example_group.description} #{example.example.description}"
-    Pact.configuration.logger.info "Verifying interactions for #{example_description}"
-    Pact.configuration.producer_verifications.each do | producer_verification |
-      producer_verification.call example_description
-    end
+    hooks.after_each Pact::RSpec.full_description(example)
   end
 
   config.after :suite do
-    Pact.configuration.logger.info "After suite"
-    Pact::Consumer::AppManager.instance.kill_all
-    Pact::Consumer::AppManager.instance.clear_all
+    hooks.after_suite
   end
 end

data/lib/pact/consumer/server.rb

@@ -0,0 +1,90 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+
+# Copied shamelessly from Capybara
+module Pact
+  class Server
+    class Middleware
+      attr_accessor :error
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env["PATH_INFO"] == "/__identify__"
+          [200, {}, [@app.object_id.to_s]]
+        else
+          begin
+            @app.call(env)
+          rescue StandardError => e
+            @error = e unless @error
+            raise e
+          end
+        end
+      end
+    end
+
+    class << self
+      def ports
+        @ports ||= {}
+      end
+    end
+
+    attr_reader :app, :port
+
+    def initialize(app, port)
+      @app = app
+      @middleware = Middleware.new(@app)
+      @server_thread = nil # supress warnings
+      @port = port
+    end
+
+    def reset_error!
+      @middleware.error = nil
+    end
+
+    def error
+      @middleware.error
+    end
+
+    def host
+      "localhost"
+    end
+
+    def responsive?
+      return false if @server_thread && @server_thread.join(0)
+
+      res = Net::HTTP.start(host, @port) { |http| http.get('/__identify__') }
+
+      if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
+        return res.body == @app.object_id.to_s
+      end
+    rescue SystemCallError
+      return false
+    end
+
+    def run_default_server(app, port)
+      require 'rack/handler/webrick'
+      Rack::Handler::WEBrick.run(app, :Port => port, :AccessLog => [], :Logger => WEBrick::Log::new(nil, 0))
+    end
+
+    def boot
+      unless responsive?
+        Pact::Server.ports[@app.object_id] = @port
+
+        @server_thread = Thread.new do
+          run_default_server(@middleware, @port)
+        end
+
+        Timeout.timeout(60) { @server_thread.join(0.1) until responsive? }
+      end
+    rescue Timeout::Error
+      raise "Rack application timed out during boot"
+    else
+      self
+    end
+
+  end
+end

data/lib/pact/consumer/spec_hooks.rb

@@ -0,0 +1,38 @@
+require 'pact/doc/generate'
+require 'pact/consumer/world'
+
+module Pact
+  module Consumer
+    class SpecHooks
+
+      def before_all
+        Pact::Consumer::AppManager.instance.spawn_all
+        FileUtils.mkdir_p Pact.configuration.pact_dir
+      end
+
+      def before_each example_description
+        Pact.consumer_world.register_pact_example_ran
+        Pact.configuration.logger.info "Clearing all expectations"
+        Pact::Consumer::AppManager.instance.ports_of_mock_services.each do | port |
+          Pact::Consumer::MockServiceClient.clear_interactions port, example_description
+        end
+      end
+
+      def after_each example_description
+        Pact.configuration.logger.info "Verifying interactions for #{example_description}"
+        Pact.configuration.provider_verifications.each do | provider_verification |
+          provider_verification.call example_description
+        end
+      end
+
+      def after_suite
+        if Pact.consumer_world.any_pact_examples_ran?
+          Pact.consumer_world.consumer_contract_builders.each { | c | c.write_pact }
+          Pact::Doc::Generate.call
+          Pact::Consumer::AppManager.instance.kill_all
+          Pact::Consumer::AppManager.instance.clear_all
+        end
+      end
+    end
+  end
+end

data/lib/pact/consumer/world.rb

@@ -0,0 +1,37 @@
+module Pact
+
+  def self.consumer_world
+    @consumer_world ||= Pact::Consumer::World.new
+  end
+
+  # internal api, for testing only
+  def self.clear_consumer_world
+    @consumer_world = nil
+  end
+
+  module Consumer
+    class World
+
+      def initialize
+        @any_pact_examples_ran = false
+      end
+
+      def consumer_contract_builders
+        @consumer_contract_builders ||= []
+      end
+
+      def add_consumer_contract_builder consumer_contract_builder
+        consumer_contract_builders << consumer_contract_builder
+      end
+
+      def register_pact_example_ran
+        @any_pact_examples_ran = true
+      end
+
+      def any_pact_examples_ran?
+        @any_pact_examples_ran
+      end
+
+    end
+  end
+end